From 92fa7030ba5b3a498f404405b903f19eff03ca39 Mon Sep 17 00:00:00 2001 From: "Joshua C. Randall" Date: Sat, 15 Jun 2019 23:32:15 +0100 Subject: [PATCH 01/61] add support for sqlite loadable extensions --- Cargo.toml | 15 +- LICENSE | 1 + libsqlite3-sys/Cargo.toml | 10 +- libsqlite3-sys/bindgen-bindings/README.md | 26 + .../bindgen_3.13.0-ext-embed.rs | 10180 ++++++++++++++ .../bindgen-bindings/bindgen_3.13.0-ext.rs | 10178 ++++++++++++++ .../bindgen-bindings/bindgen_3.13.0.rs | 4954 +++++++ .../bindgen_3.20.0-ext-embed.rs | 10509 +++++++++++++++ .../bindgen-bindings/bindgen_3.20.0-ext.rs | 10507 +++++++++++++++ .../bindgen-bindings/bindgen_3.20.0.rs | 5030 +++++++ .../bindgen_3.26.0-ext-embed.rs | 11140 ++++++++++++++++ .../bindgen-bindings/bindgen_3.26.0-ext.rs | 11138 +++++++++++++++ .../bindgen-bindings/bindgen_3.26.0.rs | 5225 ++++++++ .../bindgen_3.6.23-ext-embed.rs | 6855 ++++++++++ .../bindgen-bindings/bindgen_3.6.23-ext.rs | 6853 ++++++++++ .../bindgen-bindings/bindgen_3.6.23.rs | 3599 +++-- .../bindgen_3.6.8-ext-embed.rs | 6833 ++++++++++ .../bindgen-bindings/bindgen_3.6.8-ext.rs | 6831 ++++++++++ .../bindgen-bindings/bindgen_3.6.8.rs | 3548 +++-- .../bindgen_3.7.16-ext-embed.rs | 8584 ++++++++++++ .../bindgen-bindings/bindgen_3.7.16-ext.rs | 8582 ++++++++++++ .../bindgen-bindings/bindgen_3.7.16.rs | 4431 ++++-- .../bindgen_3.7.7-ext-embed.rs | 7831 +++++++++++ .../bindgen-bindings/bindgen_3.7.7-ext.rs | 7829 +++++++++++ .../bindgen-bindings/bindgen_3.7.7.rs | 4094 ++++-- .../generate-bindgen-bindings.sh | 78 + libsqlite3-sys/build.rs | 447 +- libsqlite3-sys/wrapper-ext.h | 2 + src/inner_connection.rs | 16 +- src/lib.rs | 2 + 30 files changed, 150120 insertions(+), 5208 deletions(-) create mode 100644 libsqlite3-sys/bindgen-bindings/README.md create mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.13.0-ext-embed.rs create mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.13.0-ext.rs create mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.13.0.rs create mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.20.0-ext-embed.rs create mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.20.0-ext.rs create mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.20.0.rs create mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.26.0-ext-embed.rs create mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.26.0-ext.rs create mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.26.0.rs create mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.6.23-ext-embed.rs create mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.6.23-ext.rs create mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext-embed.rs create mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs create mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext-embed.rs create mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs create mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.7.7-ext-embed.rs create mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.7.7-ext.rs create mode 100755 libsqlite3-sys/bindgen-bindings/generate-bindgen-bindings.sh create mode 100644 libsqlite3-sys/wrapper-ext.h diff --git a/Cargo.toml b/Cargo.toml index 40e2031fb..f180f357f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -34,6 +34,9 @@ functions = ["libsqlite3-sys/min_sqlite_version_3_7_7"] trace = ["libsqlite3-sys/min_sqlite_version_3_6_23"] bundled = ["libsqlite3-sys/bundled"] buildtime_bindgen = ["libsqlite3-sys/buildtime_bindgen"] +loadable_extension = ["libsqlite3-sys/loadable_extension"] +loadable_extension_embedded = ["libsqlite3-sys/loadable_extension_embedded"] +non_threadsafe = [] # sqlite library was built without thread safety (-DSQLITE_THREADSAFE=0) limits = [] hooks = [] i128_blob = ["byteorder"] @@ -41,13 +44,15 @@ sqlcipher = ["libsqlite3-sys/sqlcipher"] unlock_notify = ["libsqlite3-sys/unlock_notify"] # xSavepoint, xRelease and xRollbackTo: 3.7.7 (2011-06-23) vtab = ["libsqlite3-sys/min_sqlite_version_3_7_7", "lazy_static"] -# xShadowName: 3.26.0 -vtab_v3 = ["vtab"] csvtab = ["csv", "vtab"] -# pointer passing interfaces: 3.20.0 -array = ["vtab"] # session extension: 3.13.0 -session = ["libsqlite3-sys/session", "hooks"] +session = ["libsqlite3-sys/min_sqlite_version_3_13_0", "libsqlite3-sys/session", "hooks"] +# sqlite3_api_routines typedef stub: 3.20.0 +api_routines_stub = ["libsqlite3-sys/min_sqlite_version_3_20_0"] +# pointer passing interfaces: 3.20.0 +array = ["libsqlite3-sys/min_sqlite_version_3_20_0", "vtab"] +# xShadowName: 3.26.0 +vtab_v3 = ["libsqlite3-sys/min_sqlite_version_3_26_0", "vtab"] [dependencies] time = "0.1.0" diff --git a/LICENSE b/LICENSE index 3a9be6cd0..34936972d 100644 --- a/LICENSE +++ b/LICENSE @@ -1,4 +1,5 @@ Copyright (c) 2014 John Gallagher +Copyright (c) 2019 Genomics plc Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/libsqlite3-sys/Cargo.toml b/libsqlite3-sys/Cargo.toml index f7337ef1f..a3cab7f0d 100644 --- a/libsqlite3-sys/Cargo.toml +++ b/libsqlite3-sys/Cargo.toml @@ -14,12 +14,17 @@ categories = ["external-ffi-bindings"] [features] default = ["min_sqlite_version_3_6_8"] bundled = ["cc"] -buildtime_bindgen = ["bindgen", "pkg-config", "vcpkg"] +buildtime_bindgen = ["bindgen", "pkg-config", "vcpkg", "which"] +loadable_extension = ["syn", "quote"] +loadable_extension_embedded = ["loadable_extension"] sqlcipher = [] min_sqlite_version_3_6_8 = ["pkg-config", "vcpkg"] min_sqlite_version_3_6_23 = ["pkg-config", "vcpkg"] min_sqlite_version_3_7_7 = ["pkg-config", "vcpkg"] min_sqlite_version_3_7_16 = ["pkg-config", "vcpkg"] +min_sqlite_version_3_13_0 = ["pkg-config", "vcpkg"] +min_sqlite_version_3_20_0 = ["pkg-config", "vcpkg"] +min_sqlite_version_3_26_0 = ["pkg-config", "vcpkg"] # sqlite3_unlock_notify >= 3.6.12 unlock_notify = [] # 3.13.0 @@ -31,6 +36,9 @@ session = ["preupdate_hook"] bindgen = { version = "0.49", optional = true } pkg-config = { version = "0.3", optional = true } cc = { version = "1.0", optional = true } +syn = { version = "0.15.34", features = ["extra-traits", "full", "printing"], optional = true } +quote = { version = "0.6.12", optional = true } +which = { version = "2.0.1", optional = true } [target.'cfg(target_env = "msvc")'.build-dependencies] vcpkg = { version = "0.2", optional = true } diff --git a/libsqlite3-sys/bindgen-bindings/README.md b/libsqlite3-sys/bindgen-bindings/README.md new file mode 100644 index 000000000..0899504a3 --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/README.md @@ -0,0 +1,26 @@ +Pre-built sqlite bindings +========================= + +This directory contains pre built (by rust-bindgen) bindings for various sqlite versions. + +The general recipe for doing this is: + 1. Download sqlite amalgamation sources for the desired version (see links below) + 2. Expand the zip archive into a temporary directory + 3. Set environment variables `SQLITE3_LIB_DIR` and `SQLITE3_INCLUDE_DIR` to the location of the resulting source directory + 4. Build libsqlite3-sys with the feature `buildtime_bindgen` (e.g. `cargo build --features "buildtime_bindgen" -p libsqlite3-sys`) + 5. Copy `bindgen.rs` from within the `target` directory at the top level of the rusqlite workspace to an appropriate file in this directory (it will be found under `target/debug/build/libsqlite3-sys-*/out/bindgen.rs`) + +Repeat the above process for each desired version, and also re-run each build using `--features "buildtime_bindgen,loadable_extension"` to generate the `-ext.h` versions to support sqlite3 loadable extensions. + +The script `generate-bindgen-bindings.sh` will attempt to rebuild all of the prepackaged bindings. + +sqlite3 amalgamation source links +--------------------------------- +The location of the amalgamation sources used to build these are: + - [3.28.0](https://sqlite.org/2019/sqlite-amalgamation-3280000.zip) + - [3.7.16](https://sqlite.org/2013/sqlite-amalgamation-3071600.zip) + - [3.7.7](https://sqlite.org/sqlite-amalgamation-3070700.zip) + - [3.6.23](https://sqlite.org/sqlite-amalgamation-3_6_23.zip) + - [3.6.8](https://sqlite.org/sqlite-amalgamation-3_6_8.zip) + + diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.13.0-ext-embed.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.13.0-ext-embed.rs new file mode 100644 index 000000000..c09e856f7 --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.13.0-ext-embed.rs @@ -0,0 +1,10180 @@ +/* automatically generated by rust-bindgen */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.13.0\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3013000; +pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = + b"2016-05-18 10:57:30 fc49f556e48970561d7ab6a2f24fdd7d9eb81ff2\0"; +pub const SQLITE_OK: i32 = 0; +pub const SQLITE_ERROR: i32 = 1; +pub const SQLITE_INTERNAL: i32 = 2; +pub const SQLITE_PERM: i32 = 3; +pub const SQLITE_ABORT: i32 = 4; +pub const SQLITE_BUSY: i32 = 5; +pub const SQLITE_LOCKED: i32 = 6; +pub const SQLITE_NOMEM: i32 = 7; +pub const SQLITE_READONLY: i32 = 8; +pub const SQLITE_INTERRUPT: i32 = 9; +pub const SQLITE_IOERR: i32 = 10; +pub const SQLITE_CORRUPT: i32 = 11; +pub const SQLITE_NOTFOUND: i32 = 12; +pub const SQLITE_FULL: i32 = 13; +pub const SQLITE_CANTOPEN: i32 = 14; +pub const SQLITE_PROTOCOL: i32 = 15; +pub const SQLITE_EMPTY: i32 = 16; +pub const SQLITE_SCHEMA: i32 = 17; +pub const SQLITE_TOOBIG: i32 = 18; +pub const SQLITE_CONSTRAINT: i32 = 19; +pub const SQLITE_MISMATCH: i32 = 20; +pub const SQLITE_MISUSE: i32 = 21; +pub const SQLITE_NOLFS: i32 = 22; +pub const SQLITE_AUTH: i32 = 23; +pub const SQLITE_FORMAT: i32 = 24; +pub const SQLITE_RANGE: i32 = 25; +pub const SQLITE_NOTADB: i32 = 26; +pub const SQLITE_NOTICE: i32 = 27; +pub const SQLITE_WARNING: i32 = 28; +pub const SQLITE_ROW: i32 = 100; +pub const SQLITE_DONE: i32 = 101; +pub const SQLITE_IOERR_READ: i32 = 266; +pub const SQLITE_IOERR_SHORT_READ: i32 = 522; +pub const SQLITE_IOERR_WRITE: i32 = 778; +pub const SQLITE_IOERR_FSYNC: i32 = 1034; +pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; +pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; +pub const SQLITE_IOERR_FSTAT: i32 = 1802; +pub const SQLITE_IOERR_UNLOCK: i32 = 2058; +pub const SQLITE_IOERR_RDLOCK: i32 = 2314; +pub const SQLITE_IOERR_DELETE: i32 = 2570; +pub const SQLITE_IOERR_BLOCKED: i32 = 2826; +pub const SQLITE_IOERR_NOMEM: i32 = 3082; +pub const SQLITE_IOERR_ACCESS: i32 = 3338; +pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; +pub const SQLITE_IOERR_LOCK: i32 = 3850; +pub const SQLITE_IOERR_CLOSE: i32 = 4106; +pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; +pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; +pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; +pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; +pub const SQLITE_IOERR_SHMMAP: i32 = 5386; +pub const SQLITE_IOERR_SEEK: i32 = 5642; +pub const SQLITE_IOERR_DELETE_NOENT: i32 = 5898; +pub const SQLITE_IOERR_MMAP: i32 = 6154; +pub const SQLITE_IOERR_GETTEMPPATH: i32 = 6410; +pub const SQLITE_IOERR_CONVPATH: i32 = 6666; +pub const SQLITE_IOERR_VNODE: i32 = 6922; +pub const SQLITE_IOERR_AUTH: i32 = 7178; +pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; +pub const SQLITE_BUSY_RECOVERY: i32 = 261; +pub const SQLITE_BUSY_SNAPSHOT: i32 = 517; +pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; +pub const SQLITE_CANTOPEN_ISDIR: i32 = 526; +pub const SQLITE_CANTOPEN_FULLPATH: i32 = 782; +pub const SQLITE_CANTOPEN_CONVPATH: i32 = 1038; +pub const SQLITE_CORRUPT_VTAB: i32 = 267; +pub const SQLITE_READONLY_RECOVERY: i32 = 264; +pub const SQLITE_READONLY_CANTLOCK: i32 = 520; +pub const SQLITE_READONLY_ROLLBACK: i32 = 776; +pub const SQLITE_READONLY_DBMOVED: i32 = 1032; +pub const SQLITE_ABORT_ROLLBACK: i32 = 516; +pub const SQLITE_CONSTRAINT_CHECK: i32 = 275; +pub const SQLITE_CONSTRAINT_COMMITHOOK: i32 = 531; +pub const SQLITE_CONSTRAINT_FOREIGNKEY: i32 = 787; +pub const SQLITE_CONSTRAINT_FUNCTION: i32 = 1043; +pub const SQLITE_CONSTRAINT_NOTNULL: i32 = 1299; +pub const SQLITE_CONSTRAINT_PRIMARYKEY: i32 = 1555; +pub const SQLITE_CONSTRAINT_TRIGGER: i32 = 1811; +pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067; +pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323; +pub const SQLITE_CONSTRAINT_ROWID: i32 = 2579; +pub const SQLITE_NOTICE_RECOVER_WAL: i32 = 283; +pub const SQLITE_NOTICE_RECOVER_ROLLBACK: i32 = 539; +pub const SQLITE_WARNING_AUTOINDEX: i32 = 284; +pub const SQLITE_AUTH_USER: i32 = 279; +pub const SQLITE_OPEN_READONLY: i32 = 1; +pub const SQLITE_OPEN_READWRITE: i32 = 2; +pub const SQLITE_OPEN_CREATE: i32 = 4; +pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; +pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; +pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; +pub const SQLITE_OPEN_URI: i32 = 64; +pub const SQLITE_OPEN_MEMORY: i32 = 128; +pub const SQLITE_OPEN_MAIN_DB: i32 = 256; +pub const SQLITE_OPEN_TEMP_DB: i32 = 512; +pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; +pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; +pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; +pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; +pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; +pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; +pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; +pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; +pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; +pub const SQLITE_OPEN_WAL: i32 = 524288; +pub const SQLITE_IOCAP_ATOMIC: i32 = 1; +pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; +pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; +pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; +pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; +pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; +pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; +pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; +pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; +pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; +pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; +pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; +pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE: i32 = 4096; +pub const SQLITE_IOCAP_IMMUTABLE: i32 = 8192; +pub const SQLITE_LOCK_NONE: i32 = 0; +pub const SQLITE_LOCK_SHARED: i32 = 1; +pub const SQLITE_LOCK_RESERVED: i32 = 2; +pub const SQLITE_LOCK_PENDING: i32 = 3; +pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; +pub const SQLITE_SYNC_NORMAL: i32 = 2; +pub const SQLITE_SYNC_FULL: i32 = 3; +pub const SQLITE_SYNC_DATAONLY: i32 = 16; +pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; +pub const SQLITE_FCNTL_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_FCNTL_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_FCNTL_LAST_ERRNO: i32 = 4; +pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; +pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; +pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; +pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; +pub const SQLITE_FCNTL_WIN32_AV_RETRY: i32 = 9; +pub const SQLITE_FCNTL_PERSIST_WAL: i32 = 10; +pub const SQLITE_FCNTL_OVERWRITE: i32 = 11; +pub const SQLITE_FCNTL_VFSNAME: i32 = 12; +pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE: i32 = 13; +pub const SQLITE_FCNTL_PRAGMA: i32 = 14; +pub const SQLITE_FCNTL_BUSYHANDLER: i32 = 15; +pub const SQLITE_FCNTL_TEMPFILENAME: i32 = 16; +pub const SQLITE_FCNTL_MMAP_SIZE: i32 = 18; +pub const SQLITE_FCNTL_TRACE: i32 = 19; +pub const SQLITE_FCNTL_HAS_MOVED: i32 = 20; +pub const SQLITE_FCNTL_SYNC: i32 = 21; +pub const SQLITE_FCNTL_COMMIT_PHASETWO: i32 = 22; +pub const SQLITE_FCNTL_WIN32_SET_HANDLE: i32 = 23; +pub const SQLITE_FCNTL_WAL_BLOCK: i32 = 24; +pub const SQLITE_FCNTL_ZIPVFS: i32 = 25; +pub const SQLITE_FCNTL_RBU: i32 = 26; +pub const SQLITE_FCNTL_VFS_POINTER: i32 = 27; +pub const SQLITE_FCNTL_JOURNAL_POINTER: i32 = 28; +pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_LAST_ERRNO: i32 = 4; +pub const SQLITE_ACCESS_EXISTS: i32 = 0; +pub const SQLITE_ACCESS_READWRITE: i32 = 1; +pub const SQLITE_ACCESS_READ: i32 = 2; +pub const SQLITE_SHM_UNLOCK: i32 = 1; +pub const SQLITE_SHM_LOCK: i32 = 2; +pub const SQLITE_SHM_SHARED: i32 = 4; +pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; +pub const SQLITE_SHM_NLOCK: i32 = 8; +pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; +pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; +pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; +pub const SQLITE_CONFIG_MALLOC: i32 = 4; +pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; +pub const SQLITE_CONFIG_SCRATCH: i32 = 6; +pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; +pub const SQLITE_CONFIG_HEAP: i32 = 8; +pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; +pub const SQLITE_CONFIG_MUTEX: i32 = 10; +pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; +pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; +pub const SQLITE_CONFIG_PCACHE: i32 = 14; +pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; +pub const SQLITE_CONFIG_LOG: i32 = 16; +pub const SQLITE_CONFIG_URI: i32 = 17; +pub const SQLITE_CONFIG_PCACHE2: i32 = 18; +pub const SQLITE_CONFIG_GETPCACHE2: i32 = 19; +pub const SQLITE_CONFIG_COVERING_INDEX_SCAN: i32 = 20; +pub const SQLITE_CONFIG_SQLLOG: i32 = 21; +pub const SQLITE_CONFIG_MMAP_SIZE: i32 = 22; +pub const SQLITE_CONFIG_WIN32_HEAPSIZE: i32 = 23; +pub const SQLITE_CONFIG_PCACHE_HDRSZ: i32 = 24; +pub const SQLITE_CONFIG_PMASZ: i32 = 25; +pub const SQLITE_CONFIG_STMTJRNL_SPILL: i32 = 26; +pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; +pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; +pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; +pub const SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: i32 = 1004; +pub const SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: i32 = 1005; +pub const SQLITE_DENY: i32 = 1; +pub const SQLITE_IGNORE: i32 = 2; +pub const SQLITE_CREATE_INDEX: i32 = 1; +pub const SQLITE_CREATE_TABLE: i32 = 2; +pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; +pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; +pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; +pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; +pub const SQLITE_CREATE_TRIGGER: i32 = 7; +pub const SQLITE_CREATE_VIEW: i32 = 8; +pub const SQLITE_DELETE: i32 = 9; +pub const SQLITE_DROP_INDEX: i32 = 10; +pub const SQLITE_DROP_TABLE: i32 = 11; +pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; +pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; +pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; +pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; +pub const SQLITE_DROP_TRIGGER: i32 = 16; +pub const SQLITE_DROP_VIEW: i32 = 17; +pub const SQLITE_INSERT: i32 = 18; +pub const SQLITE_PRAGMA: i32 = 19; +pub const SQLITE_READ: i32 = 20; +pub const SQLITE_SELECT: i32 = 21; +pub const SQLITE_TRANSACTION: i32 = 22; +pub const SQLITE_UPDATE: i32 = 23; +pub const SQLITE_ATTACH: i32 = 24; +pub const SQLITE_DETACH: i32 = 25; +pub const SQLITE_ALTER_TABLE: i32 = 26; +pub const SQLITE_REINDEX: i32 = 27; +pub const SQLITE_ANALYZE: i32 = 28; +pub const SQLITE_CREATE_VTABLE: i32 = 29; +pub const SQLITE_DROP_VTABLE: i32 = 30; +pub const SQLITE_FUNCTION: i32 = 31; +pub const SQLITE_SAVEPOINT: i32 = 32; +pub const SQLITE_COPY: i32 = 0; +pub const SQLITE_RECURSIVE: i32 = 33; +pub const SQLITE_LIMIT_LENGTH: i32 = 0; +pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; +pub const SQLITE_LIMIT_COLUMN: i32 = 2; +pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; +pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; +pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; +pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; +pub const SQLITE_LIMIT_ATTACHED: i32 = 7; +pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; +pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; +pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; +pub const SQLITE_LIMIT_WORKER_THREADS: i32 = 11; +pub const SQLITE_INTEGER: i32 = 1; +pub const SQLITE_FLOAT: i32 = 2; +pub const SQLITE_BLOB: i32 = 4; +pub const SQLITE_NULL: i32 = 5; +pub const SQLITE_TEXT: i32 = 3; +pub const SQLITE3_TEXT: i32 = 3; +pub const SQLITE_UTF8: i32 = 1; +pub const SQLITE_UTF16LE: i32 = 2; +pub const SQLITE_UTF16BE: i32 = 3; +pub const SQLITE_UTF16: i32 = 4; +pub const SQLITE_ANY: i32 = 5; +pub const SQLITE_UTF16_ALIGNED: i32 = 8; +pub const SQLITE_DETERMINISTIC: i32 = 2048; +pub const SQLITE_INDEX_SCAN_UNIQUE: i32 = 1; +pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; +pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; +pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; +pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; +pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; +pub const SQLITE_INDEX_CONSTRAINT_LIKE: i32 = 65; +pub const SQLITE_INDEX_CONSTRAINT_GLOB: i32 = 66; +pub const SQLITE_INDEX_CONSTRAINT_REGEXP: i32 = 67; +pub const SQLITE_MUTEX_FAST: i32 = 0; +pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; +pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; +pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; +pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; +pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; +pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; +pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; +pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; +pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; +pub const SQLITE_MUTEX_STATIC_APP1: i32 = 8; +pub const SQLITE_MUTEX_STATIC_APP2: i32 = 9; +pub const SQLITE_MUTEX_STATIC_APP3: i32 = 10; +pub const SQLITE_MUTEX_STATIC_VFS1: i32 = 11; +pub const SQLITE_MUTEX_STATIC_VFS2: i32 = 12; +pub const SQLITE_MUTEX_STATIC_VFS3: i32 = 13; +pub const SQLITE_TESTCTRL_FIRST: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; +pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; +pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; +pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; +pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; +pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; +pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; +pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; +pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; +pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; +pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; +pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 17; +pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 18; +pub const SQLITE_TESTCTRL_EXPLAIN_STMT: i32 = 19; +pub const SQLITE_TESTCTRL_NEVER_CORRUPT: i32 = 20; +pub const SQLITE_TESTCTRL_VDBE_COVERAGE: i32 = 21; +pub const SQLITE_TESTCTRL_BYTEORDER: i32 = 22; +pub const SQLITE_TESTCTRL_ISINIT: i32 = 23; +pub const SQLITE_TESTCTRL_SORTER_MMAP: i32 = 24; +pub const SQLITE_TESTCTRL_IMPOSTER: i32 = 25; +pub const SQLITE_TESTCTRL_LAST: i32 = 25; +pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; +pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; +pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; +pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; +pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; +pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; +pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; +pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; +pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; +pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; +pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; +pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; +pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; +pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; +pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; +pub const SQLITE_DBSTATUS_CACHE_HIT: i32 = 7; +pub const SQLITE_DBSTATUS_CACHE_MISS: i32 = 8; +pub const SQLITE_DBSTATUS_CACHE_WRITE: i32 = 9; +pub const SQLITE_DBSTATUS_DEFERRED_FKS: i32 = 10; +pub const SQLITE_DBSTATUS_MAX: i32 = 10; +pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; +pub const SQLITE_STMTSTATUS_SORT: i32 = 2; +pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; +pub const SQLITE_STMTSTATUS_VM_STEP: i32 = 4; +pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; +pub const SQLITE_CHECKPOINT_FULL: i32 = 1; +pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; +pub const SQLITE_CHECKPOINT_TRUNCATE: i32 = 3; +pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; +pub const SQLITE_ROLLBACK: i32 = 1; +pub const SQLITE_FAIL: i32 = 3; +pub const SQLITE_REPLACE: i32 = 5; +pub const SQLITE_SCANSTAT_NLOOP: i32 = 0; +pub const SQLITE_SCANSTAT_NVISIT: i32 = 1; +pub const SQLITE_SCANSTAT_EST: i32 = 2; +pub const SQLITE_SCANSTAT_NAME: i32 = 3; +pub const SQLITE_SCANSTAT_EXPLAIN: i32 = 4; +pub const SQLITE_SCANSTAT_SELECTID: i32 = 5; +pub const NOT_WITHIN: i32 = 0; +pub const PARTLY_WITHIN: i32 = 1; +pub const FULLY_WITHIN: i32 = 2; +pub const FTS5_TOKENIZE_QUERY: i32 = 1; +pub const FTS5_TOKENIZE_PREFIX: i32 = 2; +pub const FTS5_TOKENIZE_DOCUMENT: i32 = 4; +pub const FTS5_TOKENIZE_AUX: i32 = 8; +pub const FTS5_TOKEN_COLOCATED: i32 = 1; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; +extern "C" { + #[link_name = "\u{1}sqlite3_version"] + pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3 { + _unused: [u8; 0], +} +pub type sqlite_int64 = ::std::os::raw::c_longlong; +pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; +pub type sqlite3_int64 = sqlite_int64; +pub type sqlite3_uint64 = sqlite_uint64; +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_file { + pub pMethods: *const sqlite3_io_methods, +} +#[test] +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xShmMap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iPg: ::std::os::raw::c_int, + pgsz: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xShmLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + offset: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xShmBarrier: ::std::option::Option, + pub xShmUnmap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + deleteFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iOfst: sqlite3_int64, + iAmt: ::std::os::raw::c_int, + pp: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xUnfetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iOfst: sqlite3_int64, + p: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 152usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmMap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmBarrier) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmUnmap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnfetch as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnfetch) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +pub type sqlite3_syscall_ptr = ::std::option::Option; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vfs { + pub iVersion: ::std::os::raw::c_int, + pub szOsFile: ::std::os::raw::c_int, + pub mxPathname: ::std::os::raw::c_int, + pub pNext: *mut sqlite3_vfs, + pub zName: *const ::std::os::raw::c_char, + pub pAppData: *mut ::std::os::raw::c_void, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTimeInt64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xSetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: sqlite3_syscall_ptr, + ) -> ::std::os::raw::c_int, + >, + pub xGetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> sqlite3_syscall_ptr, + >, + pub xNextSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_vfs() { + assert_eq!( + ::std::mem::size_of::(), + 168usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTimeInt64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xNextSystemCall) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mem_methods { + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub pAppData: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_mem_methods() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_stmt { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Mem { + _unused: [u8; 0], +} +pub type sqlite3_value = Mem; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_context { + _unused: [u8; 0], +} +pub type sqlite3_destructor_type = + ::std::option::Option; +extern "C" { + #[link_name = "\u{1}sqlite3_temp_directory"] + pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "\u{1}sqlite3_data_directory"] + pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSavepoint: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRelease: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRollbackTo: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 184usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSavepoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRelease) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollbackTo) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info { + pub nConstraint: ::std::os::raw::c_int, + pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, + pub nOrderBy: ::std::os::raw::c_int, + pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, + pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, + pub idxNum: ::std::os::raw::c_int, + pub idxStr: *mut ::std::os::raw::c_char, + pub needToFreeIdxStr: ::std::os::raw::c_int, + pub orderByConsumed: ::std::os::raw::c_int, + pub estimatedCost: f64, + pub estimatedRows: sqlite3_int64, + pub idxFlags: ::std::os::raw::c_int, + pub colUsed: sqlite3_uint64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint { + pub iColumn: ::std::os::raw::c_int, + pub op: ::std::os::raw::c_uchar, + pub usable: ::std::os::raw::c_uchar, + pub iTermOffset: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_orderby { + pub iColumn: ::std::os::raw::c_int, + pub desc: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint_usage { + pub argvIndex: ::std::os::raw::c_int, + pub omit: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); +} +#[test] +fn bindgen_test_layout_sqlite3_index_info() { + assert_eq!( + ::std::mem::size_of::(), + 96usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedRows as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedRows) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxFlags as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxFlags) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).colUsed as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(colUsed) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_blob { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex_methods { + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_mutex_methods() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_page { + pub pBuf: *mut ::std::os::raw::c_void, + pub pExtra: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_page() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pBuf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pExtra) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods2 { + pub iVersion: ::std::os::raw::c_int, + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + szExtra: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache_page, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, + pub xShrink: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods2() { + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iVersion as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDestroy as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShrink) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods { + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_backup { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_snapshot { + _unused: [u8; 0], +} +pub type sqlite3_rtree_dbl = f64; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_geometry { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut sqlite3_rtree_dbl, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_geometry() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(xDelUser) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_query_info { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut sqlite3_rtree_dbl, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, + pub aCoord: *mut sqlite3_rtree_dbl, + pub anQueue: *mut ::std::os::raw::c_uint, + pub nCoord: ::std::os::raw::c_int, + pub iLevel: ::std::os::raw::c_int, + pub mxLevel: ::std::os::raw::c_int, + pub iRowid: sqlite3_int64, + pub rParentScore: sqlite3_rtree_dbl, + pub eParentWithin: ::std::os::raw::c_int, + pub eWithin: ::std::os::raw::c_int, + pub rScore: sqlite3_rtree_dbl, + pub apSqlParam: *mut *mut sqlite3_value, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_query_info() { + assert_eq!( + ::std::mem::size_of::(), + 112usize, + concat!("Size of: ", stringify!(sqlite3_rtree_query_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_query_info)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).pContext as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDelUser as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(xDelUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aCoord as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(aCoord) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).anQueue as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(anQueue) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nCoord as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(nCoord) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iLevel as *const _ as usize }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(iLevel) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mxLevel as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(mxLevel) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iRowid as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(iRowid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rParentScore as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(rParentScore) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eParentWithin as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(eParentWithin) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eWithin as *const _ as usize + }, + 92usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(eWithin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).rScore as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(rScore) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).apSqlParam as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(apSqlParam) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5Context { + _unused: [u8; 0], +} +pub type fts5_extension_function = ::std::option::Option< + unsafe extern "C" fn( + pApi: *const Fts5ExtensionApi, + pFts: *mut Fts5Context, + pCtx: *mut sqlite3_context, + nVal: ::std::os::raw::c_int, + apVal: *mut *mut sqlite3_value, + ), +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5PhraseIter { + pub a: *const ::std::os::raw::c_uchar, + pub b: *const ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_Fts5PhraseIter() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Fts5PhraseIter)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Fts5PhraseIter)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).a as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Fts5PhraseIter), + "::", + stringify!(a) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).b as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Fts5PhraseIter), + "::", + stringify!(b) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5ExtensionApi { + pub iVersion: ::std::os::raw::c_int, + pub xUserData: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> *mut ::std::os::raw::c_void, + >, + pub xColumnCount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, + >, + pub xRowCount: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pnRow: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xColumnTotalSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pnToken: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTokenize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pText: *const ::std::os::raw::c_char, + nText: ::std::os::raw::c_int, + pCtx: *mut ::std::os::raw::c_void, + xToken: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + arg6: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseCount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, + >, + pub xPhraseSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xInstCount: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pnInst: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xInst: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iIdx: ::std::os::raw::c_int, + piPhrase: *mut ::std::os::raw::c_int, + piCol: *mut ::std::os::raw::c_int, + piOff: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: + ::std::option::Option sqlite3_int64>, + pub xColumnText: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pz: *mut *const ::std::os::raw::c_char, + pn: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xColumnSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pnToken: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xQueryPhrase: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + pUserData: *mut ::std::os::raw::c_void, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const Fts5ExtensionApi, + arg2: *mut Fts5Context, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub xSetAuxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pAux: *mut ::std::os::raw::c_void, + xDelete: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub xGetAuxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + bClear: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xPhraseFirst: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + arg2: *mut Fts5PhraseIter, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseNext: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + arg2: *mut Fts5PhraseIter, + piCol: *mut ::std::os::raw::c_int, + piOff: *mut ::std::os::raw::c_int, + ), + >, + pub xPhraseFirstColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + arg2: *mut Fts5PhraseIter, + arg3: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseNextColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + arg2: *mut Fts5PhraseIter, + piCol: *mut ::std::os::raw::c_int, + ), + >, +} +#[test] +fn bindgen_test_layout_Fts5ExtensionApi() { + assert_eq!( + ::std::mem::size_of::(), + 160usize, + concat!("Size of: ", stringify!(Fts5ExtensionApi)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Fts5ExtensionApi)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUserData as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xUserData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnCount as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowCount as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xRowCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xColumnTotalSize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnTotalSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xTokenize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseCount as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseSize as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInstCount as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xInstCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInst as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xInst) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnText as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnText) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnSize as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xQueryPhrase as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xQueryPhrase) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetAuxdata as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xSetAuxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetAuxdata as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xGetAuxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseFirst as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseFirst) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseNext as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseNext) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPhraseFirstColumn as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseFirstColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPhraseNextColumn as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseNextColumn) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5Tokenizer { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct fts5_tokenizer { + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + azArg: *mut *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ppOut: *mut *mut Fts5Tokenizer, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option, + pub xTokenize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Tokenizer, + pCtx: *mut ::std::os::raw::c_void, + flags: ::std::os::raw::c_int, + pText: *const ::std::os::raw::c_char, + nText: ::std::os::raw::c_int, + xToken: ::std::option::Option< + unsafe extern "C" fn( + pCtx: *mut ::std::os::raw::c_void, + tflags: ::std::os::raw::c_int, + pToken: *const ::std::os::raw::c_char, + nToken: ::std::os::raw::c_int, + iStart: ::std::os::raw::c_int, + iEnd: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_fts5_tokenizer() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(fts5_tokenizer)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(fts5_tokenizer)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xTokenize) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct fts5_api { + pub iVersion: ::std::os::raw::c_int, + pub xCreateTokenizer: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + pContext: *mut ::std::os::raw::c_void, + pTokenizer: *mut fts5_tokenizer, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub xFindTokenizer: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + ppContext: *mut *mut ::std::os::raw::c_void, + pTokenizer: *mut fts5_tokenizer, + ) -> ::std::os::raw::c_int, + >, + pub xCreateFunction: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + pContext: *mut ::std::os::raw::c_void, + xFunction: fts5_extension_function, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_fts5_api() { + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(fts5_api)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(fts5_api)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreateTokenizer as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xCreateTokenizer) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindTokenizer as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xFindTokenizer) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreateFunction as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xCreateFunction) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_api_routines { + pub aggregate_context: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub aggregate_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, + >, + pub bind_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_double: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int, + >, + pub bind_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, + ) -> ::std::os::raw::c_int, + >, + pub bind_null: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub bind_parameter_index: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub bind_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub busy_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub busy_timeout: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub changes: + ::std::option::Option ::std::os::raw::c_int>, + pub close: + ::std::option::Option ::std::os::raw::c_int>, + pub collation_needed: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub collation_needed16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub column_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_bytes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_bytes16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub column_database_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_database_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_decltype: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_decltype16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_double: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, + >, + pub column_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_int64: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, + >, + pub column_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_origin_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_origin_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_table_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_table_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar, + >, + pub column_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_type: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value, + >, + pub commit_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub complete: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub complete16: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub create_collation: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_collation16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_function16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_module: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub data_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub db_handle: + ::std::option::Option *mut sqlite3>, + pub declare_vtab: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub enable_shared_cache: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub errmsg: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, + >, + pub errmsg16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, + >, + pub exec: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub expired: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub finalize: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub free: ::std::option::Option, + pub free_table: + ::std::option::Option, + pub get_autocommit: + ::std::option::Option ::std::os::raw::c_int>, + pub get_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub get_table: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub global_recover: ::std::option::Option ::std::os::raw::c_int>, + pub interruptx: ::std::option::Option, + pub last_insert_rowid: + ::std::option::Option sqlite_int64>, + pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, + pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, + pub malloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub mprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub open16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub prepare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub profile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub progress_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ), + >, + pub realloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub result_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_double: + ::std::option::Option, + pub result_error: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_error16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_int64: + ::std::option::Option, + pub result_null: ::std::option::Option, + pub result_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16be: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16le: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_value: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), + >, + pub rollback_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub set_authorizer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub set_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, + ), + >, + pub snprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub step: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub table_column_metadata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub thread_cleanup: ::std::option::Option, + pub total_changes: + ::std::option::Option ::std::os::raw::c_int>, + pub trace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub transfer_bindings: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int, + >, + pub update_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub user_data: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, + >, + pub value_blob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_bytes16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_double: ::std::option::Option f64>, + pub value_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_int64: + ::std::option::Option sqlite_int64>, + pub value_numeric_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_text: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, + >, + pub value_text16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16be: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16le: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub vmprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub overload_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub prepare_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub clear_bindings: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub create_module_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_close: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int, + >, + pub blob_read: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_write: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub create_collation_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub file_control: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub memory_highwater: + ::std::option::Option sqlite3_int64>, + pub memory_used: ::std::option::Option sqlite3_int64>, + pub mutex_alloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub mutex_enter: ::std::option::Option, + pub mutex_free: ::std::option::Option, + pub mutex_leave: ::std::option::Option, + pub mutex_try: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub open_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub release_memory: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub result_error_nomem: ::std::option::Option, + pub result_error_toobig: + ::std::option::Option, + pub sleep: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub soft_heap_limit: ::std::option::Option, + pub vfs_find: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, + >, + pub vfs_register: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub vfs_unregister: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, + >, + pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, + pub result_zeroblob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_error_code: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub test_control: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, + >, + pub randomness: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), + >, + pub context_db_handle: + ::std::option::Option *mut sqlite3>, + pub extended_result_codes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub limit: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub next_stmt: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, + >, + pub sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, + >, + pub status: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub backup_finish: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_init: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, + ) -> *mut sqlite3_backup, + >, + pub backup_pagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_remaining: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_step: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub compileoption_get: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, + >, + pub compileoption_used: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub create_function_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub db_config: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int, + >, + pub db_mutex: + ::std::option::Option *mut sqlite3_mutex>, + pub db_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub extended_errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub log: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char, ...), + >, + pub soft_heap_limit64: + ::std::option::Option sqlite3_int64>, + pub sourceid: ::std::option::Option *const ::std::os::raw::c_char>, + pub stmt_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub strnicmp: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub unlock_notify: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub wal_autocheckpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub wal_checkpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub wal_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub blob_reopen: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob, arg2: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub vtab_config: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int, + >, + pub vtab_on_conflict: + ::std::option::Option ::std::os::raw::c_int>, + pub close_v2: + ::std::option::Option ::std::os::raw::c_int>, + pub db_filename: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, + pub db_readonly: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub db_release_memory: + ::std::option::Option ::std::os::raw::c_int>, + pub errstr: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, + >, + pub stmt_busy: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub stmt_readonly: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub stricmp: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub uri_boolean: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub uri_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64, + ) -> sqlite3_int64, + >, + pub uri_parameter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, + pub vsnprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub wal_checkpoint_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub auto_extension: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_blob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + arg6: ::std::os::raw::c_uchar, + ) -> ::std::os::raw::c_int, + >, + pub cancel_auto_extension: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub load_extension: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub malloc64: ::std::option::Option< + unsafe extern "C" fn(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void, + >, + pub msize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64, + >, + pub realloc64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_uint64, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset_auto_extension: ::std::option::Option, + pub result_blob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + ), + >, + pub result_text64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + arg5: ::std::os::raw::c_uchar, + ), + >, + pub strglob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub value_dup: ::std::option::Option< + unsafe extern "C" fn(arg1: *const sqlite3_value) -> *mut sqlite3_value, + >, + pub value_free: ::std::option::Option, + pub result_zeroblob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: sqlite3_uint64, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_uint64, + ) -> ::std::os::raw::c_int, + >, + pub value_subtype: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint, + >, + pub result_subtype: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint), + >, + pub status64: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut sqlite3_int64, + arg3: *mut sqlite3_int64, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub strlike: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_uint, + ) -> ::std::os::raw::c_int, + >, + pub db_cacheflush: + ::std::option::Option ::std::os::raw::c_int>, + pub system_errno: + ::std::option::Option ::std::os::raw::c_int>, +} +#[test] +fn bindgen_test_layout_sqlite3_api_routines() { + assert_eq!( + ::std::mem::size_of::(), + 1712usize, + concat!("Size of: ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_context as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_context) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_count as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_double as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_count as *const _ + as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_index as *const _ + as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_index) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_name as *const _ + as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text16 as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_handler as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_handler) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_timeout as *const _ as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_timeout) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed as *const _ as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_blob as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes as *const _ as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize + }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_count as *const _ as usize + }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name as *const _ + as usize + }, + 184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name16 as *const _ + as usize + }, + 192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype as *const _ as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize + }, + 208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_double as *const _ as usize + }, + 216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, + 224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_int64 as *const _ as usize + }, + 232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name as *const _ as usize + }, + 240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name16 as *const _ as usize + }, + 248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name as *const _ as usize + }, + 256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name16 as *const _ + as usize + }, + 264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name as *const _ as usize + }, + 272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name16 as *const _ + as usize + }, + 280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text as *const _ as usize + }, + 288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text16 as *const _ as usize + }, + 296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_type as *const _ as usize + }, + 304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_type) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_value as *const _ as usize + }, + 312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).commit_hook as *const _ as usize + }, + 320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(commit_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, + 328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, + 336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation as *const _ as usize + }, + 344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation16 as *const _ as usize + }, + 352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function as *const _ as usize + }, + 360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function16 as *const _ as usize + }, + 368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module as *const _ as usize + }, + 376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, + 384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(data_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, + 392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).declare_vtab as *const _ as usize + }, + 400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(declare_vtab) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).enable_shared_cache as *const _ + as usize + }, + 408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(enable_shared_cache) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, + 416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, + 424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, + 432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, + 440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(exec) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, + 448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(expired) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, + 456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(finalize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, + 464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, + 472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_autocommit as *const _ as usize + }, + 480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_autocommit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_auxdata as *const _ as usize + }, + 488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, + 496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).global_recover as *const _ as usize + }, + 504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(global_recover) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, + 512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(interruptx) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize + }, + 520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(last_insert_rowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, + 528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).libversion_number as *const _ as usize + }, + 536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion_number) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, + 544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, + 552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, + 560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, + 568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, + 576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, + 584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, + 592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(profile) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).progress_handler as *const _ as usize + }, + 600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(progress_handler) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, + 608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, + 616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob as *const _ as usize + }, + 624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_double as *const _ as usize + }, + 632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_double) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error as *const _ as usize + }, + 640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error16 as *const _ as usize + }, + 648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, + 656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_int64 as *const _ as usize + }, + 664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_null as *const _ as usize + }, + 672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text as *const _ as usize + }, + 680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16 as *const _ as usize + }, + 688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16be as *const _ as usize + }, + 696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16le as *const _ as usize + }, + 704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16le) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_value as *const _ as usize + }, + 712usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rollback_hook as *const _ as usize + }, + 720usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(rollback_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_authorizer as *const _ as usize + }, + 728usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_authorizer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_auxdata as *const _ as usize + }, + 736usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).snprintf as *const _ as usize }, + 744usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(snprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, + 752usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).table_column_metadata as *const _ + as usize + }, + 760usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(table_column_metadata) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize + }, + 768usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(thread_cleanup) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).total_changes as *const _ as usize + }, + 776usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(total_changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, + 784usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(trace) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize + }, + 792usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(transfer_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).update_hook as *const _ as usize + }, + 800usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(update_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, + 808usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(user_data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, + 816usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes as *const _ as usize + }, + 824usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize + }, + 832usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_double as *const _ as usize + }, + 840usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, + 848usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_int64 as *const _ as usize + }, + 856usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize + }, + 864usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_numeric_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, + 872usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16 as *const _ as usize + }, + 880usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16be as *const _ as usize + }, + 888usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16le as *const _ as usize + }, + 896usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16le) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, + 904usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, + 912usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vmprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).overload_function as *const _ as usize + }, + 920usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(overload_function) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, + 928usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize + }, + 936usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).clear_bindings as *const _ as usize + }, + 944usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(clear_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize + }, + 952usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize + }, + 960usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, + 968usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_bytes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, + 976usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_close) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, + 984usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, + 992usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_read) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, + 1000usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_write) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation_v2 as *const _ + as usize + }, + 1008usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).file_control as *const _ as usize + }, + 1016usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(file_control) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_highwater as *const _ as usize + }, + 1024usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_highwater) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_used as *const _ as usize + }, + 1032usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize + }, + 1040usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_alloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_enter as *const _ as usize + }, + 1048usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_enter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, + 1056usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_leave as *const _ as usize + }, + 1064usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_leave) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, + 1072usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_try) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, + 1080usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).release_memory as *const _ as usize + }, + 1088usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(release_memory) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize + }, + 1096usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_nomem) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_toobig as *const _ + as usize + }, + 1104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_toobig) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, + 1112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sleep) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize + }, + 1120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, + 1128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_find) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_register as *const _ as usize + }, + 1136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_register) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize + }, + 1144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_unregister) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize + }, + 1152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xthreadsafe) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize + }, + 1160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_code as *const _ as usize + }, + 1168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_code) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).test_control as *const _ as usize + }, + 1176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(test_control) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, + 1184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(randomness) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).context_db_handle as *const _ as usize + }, + 1192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(context_db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_result_codes as *const _ + as usize + }, + 1200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_result_codes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, + 1208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, + 1216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(next_stmt) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, + 1224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sql) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, + 1232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_finish as *const _ as usize + }, + 1240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_finish) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_init as *const _ as usize + }, + 1248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_init) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_pagecount as *const _ as usize + }, + 1256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_pagecount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_remaining as *const _ as usize + }, + 1264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_remaining) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_step as *const _ as usize + }, + 1272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_get as *const _ as usize + }, + 1280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_get) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_used as *const _ as usize + }, + 1288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function_v2 as *const _ as usize + }, + 1296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function_v2) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_config as *const _ as usize }, + 1304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_config) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_mutex as *const _ as usize }, + 1312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_mutex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_status as *const _ as usize }, + 1320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_errcode as *const _ as usize + }, + 1328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).log as *const _ as usize }, + 1336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(log) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit64 as *const _ as usize + }, + 1344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sourceid as *const _ as usize }, + 1352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sourceid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stmt_status as *const _ as usize + }, + 1360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_status) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strnicmp as *const _ as usize }, + 1368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strnicmp) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).unlock_notify as *const _ as usize + }, + 1376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(unlock_notify) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_autocheckpoint as *const _ as usize + }, + 1384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_autocheckpoint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_checkpoint as *const _ as usize + }, + 1392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_checkpoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).wal_hook as *const _ as usize }, + 1400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).blob_reopen as *const _ as usize + }, + 1408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_reopen) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_config as *const _ as usize + }, + 1416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_config) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_on_conflict as *const _ as usize + }, + 1424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_on_conflict) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close_v2 as *const _ as usize }, + 1432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_filename as *const _ as usize + }, + 1440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_filename) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_readonly as *const _ as usize + }, + 1448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_readonly) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_release_memory as *const _ as usize + }, + 1456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_release_memory) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errstr as *const _ as usize }, + 1464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errstr) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).stmt_busy as *const _ as usize }, + 1472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_busy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stmt_readonly as *const _ as usize + }, + 1480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_readonly) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).stricmp as *const _ as usize }, + 1488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stricmp) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).uri_boolean as *const _ as usize + }, + 1496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_boolean) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).uri_int64 as *const _ as usize }, + 1504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).uri_parameter as *const _ as usize + }, + 1512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_parameter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vsnprintf as *const _ as usize }, + 1520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vsnprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_checkpoint_v2 as *const _ as usize + }, + 1528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_checkpoint_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).auto_extension as *const _ as usize + }, + 1536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(auto_extension) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_blob64 as *const _ as usize + }, + 1544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text64 as *const _ as usize + }, + 1552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).cancel_auto_extension as *const _ + as usize + }, + 1560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(cancel_auto_extension) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).load_extension as *const _ as usize + }, + 1568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(load_extension) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc64 as *const _ as usize }, + 1576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).msize as *const _ as usize }, + 1584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(msize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc64 as *const _ as usize }, + 1592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).reset_auto_extension as *const _ + as usize + }, + 1600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset_auto_extension) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob64 as *const _ as usize + }, + 1608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text64 as *const _ as usize + }, + 1616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strglob as *const _ as usize }, + 1624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strglob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_dup as *const _ as usize }, + 1632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_dup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_free as *const _ as usize }, + 1640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob64 as *const _ as usize + }, + 1648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob64 as *const _ as usize + }, + 1656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_subtype as *const _ as usize + }, + 1664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_subtype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_subtype as *const _ as usize + }, + 1672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_subtype) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status64 as *const _ as usize }, + 1680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strlike as *const _ as usize }, + 1688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strlike) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_cacheflush as *const _ as usize + }, + 1696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_cacheflush) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).system_errno as *const _ as usize + }, + 1704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(system_errno) + ) + ); +} +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} + +// bindings were built with loadable_extension_embedded: +// define sqlite3_api as an extern since this code will be embedded +// within a loadable extension that defines and exports this itself +extern "C" { + #[no_mangle] + pub static mut sqlite3_api: *mut sqlite3_api_routines; +} + +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) + +pub unsafe fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_context.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_context", + " function" + )))(arg1, nBytes) +} + +pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_double", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_null", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_index.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_index", + " function" + )))(arg1, zName) +} + +pub unsafe fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_value", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_handler", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_timeout.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_timeout", + " function" + )))(arg1, ms) +} + +pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_blob", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype", + " function" + )))(arg1, i) +} + +pub unsafe fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_double", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int64", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_type", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_value", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).commit_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "commit_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete16", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_create_collation( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_collation16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_function( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_function16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function16", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_module( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).data_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "data_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).declare_vtab.expect(stringify!( + "sqlite3_api contains null pointer for ", + "declare_vtab", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).enable_shared_cache.expect(stringify!( + "sqlite3_api contains null pointer for ", + "enable_shared_cache", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errcode", + " function" + )))(db) +} + +pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_exec( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).exec.expect(stringify!( + "sqlite3_api contains null pointer for ", + "exec", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).expired.expect(stringify!( + "sqlite3_api contains null pointer for ", + "expired", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).finalize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "finalize", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free_table", + " function" + )))(result) +} + +pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_autocommit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_autocommit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_auxdata", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_get_table( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_table", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).global_recover.expect(stringify!( + "sqlite3_api contains null pointer for ", + "global_recover", + " function" + )))() +} + +pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).interruptx.expect(stringify!( + "sqlite3_api contains null pointer for ", + "interruptx", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).last_insert_rowid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "last_insert_rowid", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion", + " function" + )))() +} + +pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion_number.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion_number", + " function" + )))() +} + +pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mprintf( + arg1: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mprintf", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_open( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_open16( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_prepare( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_profile( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).profile.expect(stringify!( + "sqlite3_api contains null pointer for ", + "profile", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).progress_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "progress_handler", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_double", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_null", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16be", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16le", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_value", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).rollback_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "rollback_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_authorizer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_authorizer", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_auxdata", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_snprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).snprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "snprintf", + " function" + )))(arg1, arg2, arg3, vararg1) +} + +pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "step", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_table_column_metadata( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).table_column_metadata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "table_column_metadata", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) +} + +pub unsafe fn sqlite3_thread_cleanup() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).thread_cleanup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "thread_cleanup", + " function" + )))() +} + +pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).total_changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "total_changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).trace.expect(stringify!( + "sqlite3_api contains null pointer for ", + "trace", + " function" + )))(arg1, xTrace, arg2) +} + +pub unsafe fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).transfer_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "transfer_bindings", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).update_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "update_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).user_data.expect(stringify!( + "sqlite3_api contains null pointer for ", + "user_data", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_blob", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_double", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_numeric_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_numeric_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16be", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16le", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vmprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vmprintf", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).overload_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "overload_function", + " function" + )))(arg1, zFuncName, nArg) +} + +pub unsafe fn sqlite3_prepare_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).clear_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "clear_bindings", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_module_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module_v2", + " function" + )))(arg1, arg2, arg3, arg4, xDestroy) +} + +pub unsafe fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_open( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_open", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) +} + +pub unsafe fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_read.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_read", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_write.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_write", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_file_control( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).file_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "file_control", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_highwater.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_highwater", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_used", + " function" + )))() +} + +pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_alloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_alloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_enter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_enter", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_leave.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_leave", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_try.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_try", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_open_v2( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open_v2", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_nomem.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_nomem", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_toobig.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_toobig", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sleep.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sleep", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_find.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_find", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_register.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_register", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_unregister.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_unregister", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xthreadsafe.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xthreadsafe", + " function" + )))() +} + +pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_code.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_code", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_test_control( + arg1: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).test_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "test_control", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).randomness.expect(stringify!( + "sqlite3_api contains null pointer for ", + "randomness", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).context_db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "context_db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_result_codes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_result_codes", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_limit( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "limit", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).next_stmt.expect(stringify!( + "sqlite3_api contains null pointer for ", + "next_stmt", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_status( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_finish.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_finish", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_init( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, +) -> *mut sqlite3_backup { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_init.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_init", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_pagecount.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_pagecount", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_remaining.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_remaining", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_step( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_step", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_compileoption_get( + arg1: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_get.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_get", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_compileoption_used( + arg1: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_used", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_function_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal, xDestroy) +} + +pub unsafe fn sqlite3_db_config( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, + vararg2: &mut i32, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_config", + " function" + )))(arg1, arg2, vararg1, vararg2) +} + +pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_mutex.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_mutex", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_db_status( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_status", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_errcode", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_log( + arg1: ::std::os::raw::c_int, + arg2: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).log.expect(stringify!( + "sqlite3_api contains null pointer for ", + "log", + " function" + )))(arg1, arg2, vararg1) +} + +pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sourceid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sourceid", + " function" + )))() +} + +pub unsafe fn sqlite3_stmt_status( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_status", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_strnicmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strnicmp.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strnicmp", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_unlock_notify( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int), + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).unlock_notify.expect(stringify!( + "sqlite3_api contains null pointer for ", + "unlock_notify", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_wal_autocheckpoint( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_autocheckpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_checkpoint( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_checkpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_checkpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_reopen( + arg1: *mut sqlite3_blob, + arg2: sqlite3_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_reopen.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_reopen", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vtab_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_config", + " function" + )))(arg1, op, vararg1) +} + +pub unsafe fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_on_conflict.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_on_conflict", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close_v2", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_db_filename( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_filename.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_filename", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_db_readonly( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_readonly.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_readonly", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errstr.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errstr", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_busy.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_busy", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stmt_readonly(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_readonly.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_readonly", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stricmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stricmp.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stricmp", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_uri_boolean( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_boolean.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_boolean", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_uri_int64( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64, +) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_uri_parameter( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_parameter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_parameter", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vsnprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vsnprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vsnprintf", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_wal_checkpoint_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_checkpoint_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_checkpoint_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_auto_extension( + arg1: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).auto_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "auto_extension", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob64", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_text64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + arg6: ::std::os::raw::c_uchar, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text64", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_cancel_auto_extension( + arg1: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).cancel_auto_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "cancel_auto_extension", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_load_extension( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).load_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "load_extension", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_malloc64(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_msize(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).msize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "msize", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_realloc64( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_uint64, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset_auto_extension() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset_auto_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset_auto_extension", + " function" + )))() +} + +pub unsafe fn sqlite3_result_blob64( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob64", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text64( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + arg5: ::std::os::raw::c_uchar, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text64", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_strglob( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strglob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strglob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_value_dup(arg1: *const sqlite3_value) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_dup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_dup", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_free(arg1: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_zeroblob64( + arg1: *mut sqlite3_context, + arg2: sqlite3_uint64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_zeroblob64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_uint64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_value_subtype(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_subtype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_subtype", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_subtype(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_subtype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_subtype", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_status64( + arg1: ::std::os::raw::c_int, + arg2: *mut sqlite3_int64, + arg3: *mut sqlite3_int64, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status64", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_strlike( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_uint, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strlike.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strlike", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_db_cacheflush(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_cacheflush.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_cacheflush", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_system_errno(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).system_errno.expect(stringify!( + "sqlite3_api contains null pointer for ", + "system_errno", + " function" + )))(arg1) +} diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.13.0-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.13.0-ext.rs new file mode 100644 index 000000000..a3e11da90 --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.13.0-ext.rs @@ -0,0 +1,10178 @@ +/* automatically generated by rust-bindgen */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.13.0\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3013000; +pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = + b"2016-05-18 10:57:30 fc49f556e48970561d7ab6a2f24fdd7d9eb81ff2\0"; +pub const SQLITE_OK: i32 = 0; +pub const SQLITE_ERROR: i32 = 1; +pub const SQLITE_INTERNAL: i32 = 2; +pub const SQLITE_PERM: i32 = 3; +pub const SQLITE_ABORT: i32 = 4; +pub const SQLITE_BUSY: i32 = 5; +pub const SQLITE_LOCKED: i32 = 6; +pub const SQLITE_NOMEM: i32 = 7; +pub const SQLITE_READONLY: i32 = 8; +pub const SQLITE_INTERRUPT: i32 = 9; +pub const SQLITE_IOERR: i32 = 10; +pub const SQLITE_CORRUPT: i32 = 11; +pub const SQLITE_NOTFOUND: i32 = 12; +pub const SQLITE_FULL: i32 = 13; +pub const SQLITE_CANTOPEN: i32 = 14; +pub const SQLITE_PROTOCOL: i32 = 15; +pub const SQLITE_EMPTY: i32 = 16; +pub const SQLITE_SCHEMA: i32 = 17; +pub const SQLITE_TOOBIG: i32 = 18; +pub const SQLITE_CONSTRAINT: i32 = 19; +pub const SQLITE_MISMATCH: i32 = 20; +pub const SQLITE_MISUSE: i32 = 21; +pub const SQLITE_NOLFS: i32 = 22; +pub const SQLITE_AUTH: i32 = 23; +pub const SQLITE_FORMAT: i32 = 24; +pub const SQLITE_RANGE: i32 = 25; +pub const SQLITE_NOTADB: i32 = 26; +pub const SQLITE_NOTICE: i32 = 27; +pub const SQLITE_WARNING: i32 = 28; +pub const SQLITE_ROW: i32 = 100; +pub const SQLITE_DONE: i32 = 101; +pub const SQLITE_IOERR_READ: i32 = 266; +pub const SQLITE_IOERR_SHORT_READ: i32 = 522; +pub const SQLITE_IOERR_WRITE: i32 = 778; +pub const SQLITE_IOERR_FSYNC: i32 = 1034; +pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; +pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; +pub const SQLITE_IOERR_FSTAT: i32 = 1802; +pub const SQLITE_IOERR_UNLOCK: i32 = 2058; +pub const SQLITE_IOERR_RDLOCK: i32 = 2314; +pub const SQLITE_IOERR_DELETE: i32 = 2570; +pub const SQLITE_IOERR_BLOCKED: i32 = 2826; +pub const SQLITE_IOERR_NOMEM: i32 = 3082; +pub const SQLITE_IOERR_ACCESS: i32 = 3338; +pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; +pub const SQLITE_IOERR_LOCK: i32 = 3850; +pub const SQLITE_IOERR_CLOSE: i32 = 4106; +pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; +pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; +pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; +pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; +pub const SQLITE_IOERR_SHMMAP: i32 = 5386; +pub const SQLITE_IOERR_SEEK: i32 = 5642; +pub const SQLITE_IOERR_DELETE_NOENT: i32 = 5898; +pub const SQLITE_IOERR_MMAP: i32 = 6154; +pub const SQLITE_IOERR_GETTEMPPATH: i32 = 6410; +pub const SQLITE_IOERR_CONVPATH: i32 = 6666; +pub const SQLITE_IOERR_VNODE: i32 = 6922; +pub const SQLITE_IOERR_AUTH: i32 = 7178; +pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; +pub const SQLITE_BUSY_RECOVERY: i32 = 261; +pub const SQLITE_BUSY_SNAPSHOT: i32 = 517; +pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; +pub const SQLITE_CANTOPEN_ISDIR: i32 = 526; +pub const SQLITE_CANTOPEN_FULLPATH: i32 = 782; +pub const SQLITE_CANTOPEN_CONVPATH: i32 = 1038; +pub const SQLITE_CORRUPT_VTAB: i32 = 267; +pub const SQLITE_READONLY_RECOVERY: i32 = 264; +pub const SQLITE_READONLY_CANTLOCK: i32 = 520; +pub const SQLITE_READONLY_ROLLBACK: i32 = 776; +pub const SQLITE_READONLY_DBMOVED: i32 = 1032; +pub const SQLITE_ABORT_ROLLBACK: i32 = 516; +pub const SQLITE_CONSTRAINT_CHECK: i32 = 275; +pub const SQLITE_CONSTRAINT_COMMITHOOK: i32 = 531; +pub const SQLITE_CONSTRAINT_FOREIGNKEY: i32 = 787; +pub const SQLITE_CONSTRAINT_FUNCTION: i32 = 1043; +pub const SQLITE_CONSTRAINT_NOTNULL: i32 = 1299; +pub const SQLITE_CONSTRAINT_PRIMARYKEY: i32 = 1555; +pub const SQLITE_CONSTRAINT_TRIGGER: i32 = 1811; +pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067; +pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323; +pub const SQLITE_CONSTRAINT_ROWID: i32 = 2579; +pub const SQLITE_NOTICE_RECOVER_WAL: i32 = 283; +pub const SQLITE_NOTICE_RECOVER_ROLLBACK: i32 = 539; +pub const SQLITE_WARNING_AUTOINDEX: i32 = 284; +pub const SQLITE_AUTH_USER: i32 = 279; +pub const SQLITE_OPEN_READONLY: i32 = 1; +pub const SQLITE_OPEN_READWRITE: i32 = 2; +pub const SQLITE_OPEN_CREATE: i32 = 4; +pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; +pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; +pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; +pub const SQLITE_OPEN_URI: i32 = 64; +pub const SQLITE_OPEN_MEMORY: i32 = 128; +pub const SQLITE_OPEN_MAIN_DB: i32 = 256; +pub const SQLITE_OPEN_TEMP_DB: i32 = 512; +pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; +pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; +pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; +pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; +pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; +pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; +pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; +pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; +pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; +pub const SQLITE_OPEN_WAL: i32 = 524288; +pub const SQLITE_IOCAP_ATOMIC: i32 = 1; +pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; +pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; +pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; +pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; +pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; +pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; +pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; +pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; +pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; +pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; +pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; +pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE: i32 = 4096; +pub const SQLITE_IOCAP_IMMUTABLE: i32 = 8192; +pub const SQLITE_LOCK_NONE: i32 = 0; +pub const SQLITE_LOCK_SHARED: i32 = 1; +pub const SQLITE_LOCK_RESERVED: i32 = 2; +pub const SQLITE_LOCK_PENDING: i32 = 3; +pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; +pub const SQLITE_SYNC_NORMAL: i32 = 2; +pub const SQLITE_SYNC_FULL: i32 = 3; +pub const SQLITE_SYNC_DATAONLY: i32 = 16; +pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; +pub const SQLITE_FCNTL_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_FCNTL_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_FCNTL_LAST_ERRNO: i32 = 4; +pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; +pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; +pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; +pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; +pub const SQLITE_FCNTL_WIN32_AV_RETRY: i32 = 9; +pub const SQLITE_FCNTL_PERSIST_WAL: i32 = 10; +pub const SQLITE_FCNTL_OVERWRITE: i32 = 11; +pub const SQLITE_FCNTL_VFSNAME: i32 = 12; +pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE: i32 = 13; +pub const SQLITE_FCNTL_PRAGMA: i32 = 14; +pub const SQLITE_FCNTL_BUSYHANDLER: i32 = 15; +pub const SQLITE_FCNTL_TEMPFILENAME: i32 = 16; +pub const SQLITE_FCNTL_MMAP_SIZE: i32 = 18; +pub const SQLITE_FCNTL_TRACE: i32 = 19; +pub const SQLITE_FCNTL_HAS_MOVED: i32 = 20; +pub const SQLITE_FCNTL_SYNC: i32 = 21; +pub const SQLITE_FCNTL_COMMIT_PHASETWO: i32 = 22; +pub const SQLITE_FCNTL_WIN32_SET_HANDLE: i32 = 23; +pub const SQLITE_FCNTL_WAL_BLOCK: i32 = 24; +pub const SQLITE_FCNTL_ZIPVFS: i32 = 25; +pub const SQLITE_FCNTL_RBU: i32 = 26; +pub const SQLITE_FCNTL_VFS_POINTER: i32 = 27; +pub const SQLITE_FCNTL_JOURNAL_POINTER: i32 = 28; +pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_LAST_ERRNO: i32 = 4; +pub const SQLITE_ACCESS_EXISTS: i32 = 0; +pub const SQLITE_ACCESS_READWRITE: i32 = 1; +pub const SQLITE_ACCESS_READ: i32 = 2; +pub const SQLITE_SHM_UNLOCK: i32 = 1; +pub const SQLITE_SHM_LOCK: i32 = 2; +pub const SQLITE_SHM_SHARED: i32 = 4; +pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; +pub const SQLITE_SHM_NLOCK: i32 = 8; +pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; +pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; +pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; +pub const SQLITE_CONFIG_MALLOC: i32 = 4; +pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; +pub const SQLITE_CONFIG_SCRATCH: i32 = 6; +pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; +pub const SQLITE_CONFIG_HEAP: i32 = 8; +pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; +pub const SQLITE_CONFIG_MUTEX: i32 = 10; +pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; +pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; +pub const SQLITE_CONFIG_PCACHE: i32 = 14; +pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; +pub const SQLITE_CONFIG_LOG: i32 = 16; +pub const SQLITE_CONFIG_URI: i32 = 17; +pub const SQLITE_CONFIG_PCACHE2: i32 = 18; +pub const SQLITE_CONFIG_GETPCACHE2: i32 = 19; +pub const SQLITE_CONFIG_COVERING_INDEX_SCAN: i32 = 20; +pub const SQLITE_CONFIG_SQLLOG: i32 = 21; +pub const SQLITE_CONFIG_MMAP_SIZE: i32 = 22; +pub const SQLITE_CONFIG_WIN32_HEAPSIZE: i32 = 23; +pub const SQLITE_CONFIG_PCACHE_HDRSZ: i32 = 24; +pub const SQLITE_CONFIG_PMASZ: i32 = 25; +pub const SQLITE_CONFIG_STMTJRNL_SPILL: i32 = 26; +pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; +pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; +pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; +pub const SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: i32 = 1004; +pub const SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: i32 = 1005; +pub const SQLITE_DENY: i32 = 1; +pub const SQLITE_IGNORE: i32 = 2; +pub const SQLITE_CREATE_INDEX: i32 = 1; +pub const SQLITE_CREATE_TABLE: i32 = 2; +pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; +pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; +pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; +pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; +pub const SQLITE_CREATE_TRIGGER: i32 = 7; +pub const SQLITE_CREATE_VIEW: i32 = 8; +pub const SQLITE_DELETE: i32 = 9; +pub const SQLITE_DROP_INDEX: i32 = 10; +pub const SQLITE_DROP_TABLE: i32 = 11; +pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; +pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; +pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; +pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; +pub const SQLITE_DROP_TRIGGER: i32 = 16; +pub const SQLITE_DROP_VIEW: i32 = 17; +pub const SQLITE_INSERT: i32 = 18; +pub const SQLITE_PRAGMA: i32 = 19; +pub const SQLITE_READ: i32 = 20; +pub const SQLITE_SELECT: i32 = 21; +pub const SQLITE_TRANSACTION: i32 = 22; +pub const SQLITE_UPDATE: i32 = 23; +pub const SQLITE_ATTACH: i32 = 24; +pub const SQLITE_DETACH: i32 = 25; +pub const SQLITE_ALTER_TABLE: i32 = 26; +pub const SQLITE_REINDEX: i32 = 27; +pub const SQLITE_ANALYZE: i32 = 28; +pub const SQLITE_CREATE_VTABLE: i32 = 29; +pub const SQLITE_DROP_VTABLE: i32 = 30; +pub const SQLITE_FUNCTION: i32 = 31; +pub const SQLITE_SAVEPOINT: i32 = 32; +pub const SQLITE_COPY: i32 = 0; +pub const SQLITE_RECURSIVE: i32 = 33; +pub const SQLITE_LIMIT_LENGTH: i32 = 0; +pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; +pub const SQLITE_LIMIT_COLUMN: i32 = 2; +pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; +pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; +pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; +pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; +pub const SQLITE_LIMIT_ATTACHED: i32 = 7; +pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; +pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; +pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; +pub const SQLITE_LIMIT_WORKER_THREADS: i32 = 11; +pub const SQLITE_INTEGER: i32 = 1; +pub const SQLITE_FLOAT: i32 = 2; +pub const SQLITE_BLOB: i32 = 4; +pub const SQLITE_NULL: i32 = 5; +pub const SQLITE_TEXT: i32 = 3; +pub const SQLITE3_TEXT: i32 = 3; +pub const SQLITE_UTF8: i32 = 1; +pub const SQLITE_UTF16LE: i32 = 2; +pub const SQLITE_UTF16BE: i32 = 3; +pub const SQLITE_UTF16: i32 = 4; +pub const SQLITE_ANY: i32 = 5; +pub const SQLITE_UTF16_ALIGNED: i32 = 8; +pub const SQLITE_DETERMINISTIC: i32 = 2048; +pub const SQLITE_INDEX_SCAN_UNIQUE: i32 = 1; +pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; +pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; +pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; +pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; +pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; +pub const SQLITE_INDEX_CONSTRAINT_LIKE: i32 = 65; +pub const SQLITE_INDEX_CONSTRAINT_GLOB: i32 = 66; +pub const SQLITE_INDEX_CONSTRAINT_REGEXP: i32 = 67; +pub const SQLITE_MUTEX_FAST: i32 = 0; +pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; +pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; +pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; +pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; +pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; +pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; +pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; +pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; +pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; +pub const SQLITE_MUTEX_STATIC_APP1: i32 = 8; +pub const SQLITE_MUTEX_STATIC_APP2: i32 = 9; +pub const SQLITE_MUTEX_STATIC_APP3: i32 = 10; +pub const SQLITE_MUTEX_STATIC_VFS1: i32 = 11; +pub const SQLITE_MUTEX_STATIC_VFS2: i32 = 12; +pub const SQLITE_MUTEX_STATIC_VFS3: i32 = 13; +pub const SQLITE_TESTCTRL_FIRST: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; +pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; +pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; +pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; +pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; +pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; +pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; +pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; +pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; +pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; +pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; +pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 17; +pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 18; +pub const SQLITE_TESTCTRL_EXPLAIN_STMT: i32 = 19; +pub const SQLITE_TESTCTRL_NEVER_CORRUPT: i32 = 20; +pub const SQLITE_TESTCTRL_VDBE_COVERAGE: i32 = 21; +pub const SQLITE_TESTCTRL_BYTEORDER: i32 = 22; +pub const SQLITE_TESTCTRL_ISINIT: i32 = 23; +pub const SQLITE_TESTCTRL_SORTER_MMAP: i32 = 24; +pub const SQLITE_TESTCTRL_IMPOSTER: i32 = 25; +pub const SQLITE_TESTCTRL_LAST: i32 = 25; +pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; +pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; +pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; +pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; +pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; +pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; +pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; +pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; +pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; +pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; +pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; +pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; +pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; +pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; +pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; +pub const SQLITE_DBSTATUS_CACHE_HIT: i32 = 7; +pub const SQLITE_DBSTATUS_CACHE_MISS: i32 = 8; +pub const SQLITE_DBSTATUS_CACHE_WRITE: i32 = 9; +pub const SQLITE_DBSTATUS_DEFERRED_FKS: i32 = 10; +pub const SQLITE_DBSTATUS_MAX: i32 = 10; +pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; +pub const SQLITE_STMTSTATUS_SORT: i32 = 2; +pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; +pub const SQLITE_STMTSTATUS_VM_STEP: i32 = 4; +pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; +pub const SQLITE_CHECKPOINT_FULL: i32 = 1; +pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; +pub const SQLITE_CHECKPOINT_TRUNCATE: i32 = 3; +pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; +pub const SQLITE_ROLLBACK: i32 = 1; +pub const SQLITE_FAIL: i32 = 3; +pub const SQLITE_REPLACE: i32 = 5; +pub const SQLITE_SCANSTAT_NLOOP: i32 = 0; +pub const SQLITE_SCANSTAT_NVISIT: i32 = 1; +pub const SQLITE_SCANSTAT_EST: i32 = 2; +pub const SQLITE_SCANSTAT_NAME: i32 = 3; +pub const SQLITE_SCANSTAT_EXPLAIN: i32 = 4; +pub const SQLITE_SCANSTAT_SELECTID: i32 = 5; +pub const NOT_WITHIN: i32 = 0; +pub const PARTLY_WITHIN: i32 = 1; +pub const FULLY_WITHIN: i32 = 2; +pub const FTS5_TOKENIZE_QUERY: i32 = 1; +pub const FTS5_TOKENIZE_PREFIX: i32 = 2; +pub const FTS5_TOKENIZE_DOCUMENT: i32 = 4; +pub const FTS5_TOKENIZE_AUX: i32 = 8; +pub const FTS5_TOKEN_COLOCATED: i32 = 1; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; +extern "C" { + #[link_name = "\u{1}sqlite3_version"] + pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3 { + _unused: [u8; 0], +} +pub type sqlite_int64 = ::std::os::raw::c_longlong; +pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; +pub type sqlite3_int64 = sqlite_int64; +pub type sqlite3_uint64 = sqlite_uint64; +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_file { + pub pMethods: *const sqlite3_io_methods, +} +#[test] +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xShmMap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iPg: ::std::os::raw::c_int, + pgsz: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xShmLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + offset: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xShmBarrier: ::std::option::Option, + pub xShmUnmap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + deleteFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iOfst: sqlite3_int64, + iAmt: ::std::os::raw::c_int, + pp: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xUnfetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iOfst: sqlite3_int64, + p: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 152usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmMap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmBarrier) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmUnmap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnfetch as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnfetch) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +pub type sqlite3_syscall_ptr = ::std::option::Option; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vfs { + pub iVersion: ::std::os::raw::c_int, + pub szOsFile: ::std::os::raw::c_int, + pub mxPathname: ::std::os::raw::c_int, + pub pNext: *mut sqlite3_vfs, + pub zName: *const ::std::os::raw::c_char, + pub pAppData: *mut ::std::os::raw::c_void, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTimeInt64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xSetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: sqlite3_syscall_ptr, + ) -> ::std::os::raw::c_int, + >, + pub xGetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> sqlite3_syscall_ptr, + >, + pub xNextSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_vfs() { + assert_eq!( + ::std::mem::size_of::(), + 168usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTimeInt64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xNextSystemCall) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mem_methods { + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub pAppData: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_mem_methods() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_stmt { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Mem { + _unused: [u8; 0], +} +pub type sqlite3_value = Mem; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_context { + _unused: [u8; 0], +} +pub type sqlite3_destructor_type = + ::std::option::Option; +extern "C" { + #[link_name = "\u{1}sqlite3_temp_directory"] + pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "\u{1}sqlite3_data_directory"] + pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSavepoint: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRelease: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRollbackTo: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 184usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSavepoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRelease) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollbackTo) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info { + pub nConstraint: ::std::os::raw::c_int, + pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, + pub nOrderBy: ::std::os::raw::c_int, + pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, + pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, + pub idxNum: ::std::os::raw::c_int, + pub idxStr: *mut ::std::os::raw::c_char, + pub needToFreeIdxStr: ::std::os::raw::c_int, + pub orderByConsumed: ::std::os::raw::c_int, + pub estimatedCost: f64, + pub estimatedRows: sqlite3_int64, + pub idxFlags: ::std::os::raw::c_int, + pub colUsed: sqlite3_uint64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint { + pub iColumn: ::std::os::raw::c_int, + pub op: ::std::os::raw::c_uchar, + pub usable: ::std::os::raw::c_uchar, + pub iTermOffset: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_orderby { + pub iColumn: ::std::os::raw::c_int, + pub desc: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint_usage { + pub argvIndex: ::std::os::raw::c_int, + pub omit: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); +} +#[test] +fn bindgen_test_layout_sqlite3_index_info() { + assert_eq!( + ::std::mem::size_of::(), + 96usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedRows as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedRows) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxFlags as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxFlags) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).colUsed as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(colUsed) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_blob { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex_methods { + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_mutex_methods() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_page { + pub pBuf: *mut ::std::os::raw::c_void, + pub pExtra: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_page() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pBuf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pExtra) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods2 { + pub iVersion: ::std::os::raw::c_int, + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + szExtra: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache_page, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, + pub xShrink: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods2() { + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iVersion as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDestroy as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShrink) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods { + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_backup { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_snapshot { + _unused: [u8; 0], +} +pub type sqlite3_rtree_dbl = f64; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_geometry { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut sqlite3_rtree_dbl, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_geometry() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(xDelUser) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_query_info { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut sqlite3_rtree_dbl, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, + pub aCoord: *mut sqlite3_rtree_dbl, + pub anQueue: *mut ::std::os::raw::c_uint, + pub nCoord: ::std::os::raw::c_int, + pub iLevel: ::std::os::raw::c_int, + pub mxLevel: ::std::os::raw::c_int, + pub iRowid: sqlite3_int64, + pub rParentScore: sqlite3_rtree_dbl, + pub eParentWithin: ::std::os::raw::c_int, + pub eWithin: ::std::os::raw::c_int, + pub rScore: sqlite3_rtree_dbl, + pub apSqlParam: *mut *mut sqlite3_value, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_query_info() { + assert_eq!( + ::std::mem::size_of::(), + 112usize, + concat!("Size of: ", stringify!(sqlite3_rtree_query_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_query_info)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).pContext as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDelUser as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(xDelUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aCoord as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(aCoord) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).anQueue as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(anQueue) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nCoord as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(nCoord) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iLevel as *const _ as usize }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(iLevel) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mxLevel as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(mxLevel) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iRowid as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(iRowid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rParentScore as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(rParentScore) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eParentWithin as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(eParentWithin) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eWithin as *const _ as usize + }, + 92usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(eWithin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).rScore as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(rScore) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).apSqlParam as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(apSqlParam) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5Context { + _unused: [u8; 0], +} +pub type fts5_extension_function = ::std::option::Option< + unsafe extern "C" fn( + pApi: *const Fts5ExtensionApi, + pFts: *mut Fts5Context, + pCtx: *mut sqlite3_context, + nVal: ::std::os::raw::c_int, + apVal: *mut *mut sqlite3_value, + ), +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5PhraseIter { + pub a: *const ::std::os::raw::c_uchar, + pub b: *const ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_Fts5PhraseIter() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Fts5PhraseIter)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Fts5PhraseIter)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).a as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Fts5PhraseIter), + "::", + stringify!(a) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).b as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Fts5PhraseIter), + "::", + stringify!(b) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5ExtensionApi { + pub iVersion: ::std::os::raw::c_int, + pub xUserData: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> *mut ::std::os::raw::c_void, + >, + pub xColumnCount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, + >, + pub xRowCount: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pnRow: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xColumnTotalSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pnToken: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTokenize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pText: *const ::std::os::raw::c_char, + nText: ::std::os::raw::c_int, + pCtx: *mut ::std::os::raw::c_void, + xToken: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + arg6: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseCount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, + >, + pub xPhraseSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xInstCount: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pnInst: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xInst: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iIdx: ::std::os::raw::c_int, + piPhrase: *mut ::std::os::raw::c_int, + piCol: *mut ::std::os::raw::c_int, + piOff: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: + ::std::option::Option sqlite3_int64>, + pub xColumnText: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pz: *mut *const ::std::os::raw::c_char, + pn: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xColumnSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pnToken: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xQueryPhrase: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + pUserData: *mut ::std::os::raw::c_void, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const Fts5ExtensionApi, + arg2: *mut Fts5Context, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub xSetAuxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pAux: *mut ::std::os::raw::c_void, + xDelete: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub xGetAuxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + bClear: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xPhraseFirst: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + arg2: *mut Fts5PhraseIter, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseNext: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + arg2: *mut Fts5PhraseIter, + piCol: *mut ::std::os::raw::c_int, + piOff: *mut ::std::os::raw::c_int, + ), + >, + pub xPhraseFirstColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + arg2: *mut Fts5PhraseIter, + arg3: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseNextColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + arg2: *mut Fts5PhraseIter, + piCol: *mut ::std::os::raw::c_int, + ), + >, +} +#[test] +fn bindgen_test_layout_Fts5ExtensionApi() { + assert_eq!( + ::std::mem::size_of::(), + 160usize, + concat!("Size of: ", stringify!(Fts5ExtensionApi)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Fts5ExtensionApi)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUserData as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xUserData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnCount as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowCount as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xRowCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xColumnTotalSize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnTotalSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xTokenize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseCount as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseSize as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInstCount as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xInstCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInst as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xInst) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnText as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnText) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnSize as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xQueryPhrase as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xQueryPhrase) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetAuxdata as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xSetAuxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetAuxdata as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xGetAuxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseFirst as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseFirst) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseNext as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseNext) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPhraseFirstColumn as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseFirstColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPhraseNextColumn as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseNextColumn) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5Tokenizer { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct fts5_tokenizer { + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + azArg: *mut *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ppOut: *mut *mut Fts5Tokenizer, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option, + pub xTokenize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Tokenizer, + pCtx: *mut ::std::os::raw::c_void, + flags: ::std::os::raw::c_int, + pText: *const ::std::os::raw::c_char, + nText: ::std::os::raw::c_int, + xToken: ::std::option::Option< + unsafe extern "C" fn( + pCtx: *mut ::std::os::raw::c_void, + tflags: ::std::os::raw::c_int, + pToken: *const ::std::os::raw::c_char, + nToken: ::std::os::raw::c_int, + iStart: ::std::os::raw::c_int, + iEnd: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_fts5_tokenizer() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(fts5_tokenizer)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(fts5_tokenizer)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xTokenize) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct fts5_api { + pub iVersion: ::std::os::raw::c_int, + pub xCreateTokenizer: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + pContext: *mut ::std::os::raw::c_void, + pTokenizer: *mut fts5_tokenizer, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub xFindTokenizer: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + ppContext: *mut *mut ::std::os::raw::c_void, + pTokenizer: *mut fts5_tokenizer, + ) -> ::std::os::raw::c_int, + >, + pub xCreateFunction: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + pContext: *mut ::std::os::raw::c_void, + xFunction: fts5_extension_function, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_fts5_api() { + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(fts5_api)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(fts5_api)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreateTokenizer as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xCreateTokenizer) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindTokenizer as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xFindTokenizer) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreateFunction as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xCreateFunction) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_api_routines { + pub aggregate_context: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub aggregate_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, + >, + pub bind_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_double: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int, + >, + pub bind_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, + ) -> ::std::os::raw::c_int, + >, + pub bind_null: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub bind_parameter_index: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub bind_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub busy_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub busy_timeout: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub changes: + ::std::option::Option ::std::os::raw::c_int>, + pub close: + ::std::option::Option ::std::os::raw::c_int>, + pub collation_needed: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub collation_needed16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub column_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_bytes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_bytes16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub column_database_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_database_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_decltype: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_decltype16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_double: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, + >, + pub column_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_int64: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, + >, + pub column_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_origin_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_origin_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_table_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_table_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar, + >, + pub column_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_type: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value, + >, + pub commit_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub complete: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub complete16: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub create_collation: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_collation16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_function16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_module: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub data_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub db_handle: + ::std::option::Option *mut sqlite3>, + pub declare_vtab: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub enable_shared_cache: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub errmsg: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, + >, + pub errmsg16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, + >, + pub exec: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub expired: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub finalize: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub free: ::std::option::Option, + pub free_table: + ::std::option::Option, + pub get_autocommit: + ::std::option::Option ::std::os::raw::c_int>, + pub get_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub get_table: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub global_recover: ::std::option::Option ::std::os::raw::c_int>, + pub interruptx: ::std::option::Option, + pub last_insert_rowid: + ::std::option::Option sqlite_int64>, + pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, + pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, + pub malloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub mprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub open16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub prepare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub profile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub progress_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ), + >, + pub realloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub result_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_double: + ::std::option::Option, + pub result_error: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_error16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_int64: + ::std::option::Option, + pub result_null: ::std::option::Option, + pub result_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16be: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16le: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_value: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), + >, + pub rollback_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub set_authorizer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub set_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, + ), + >, + pub snprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub step: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub table_column_metadata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub thread_cleanup: ::std::option::Option, + pub total_changes: + ::std::option::Option ::std::os::raw::c_int>, + pub trace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub transfer_bindings: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int, + >, + pub update_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub user_data: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, + >, + pub value_blob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_bytes16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_double: ::std::option::Option f64>, + pub value_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_int64: + ::std::option::Option sqlite_int64>, + pub value_numeric_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_text: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, + >, + pub value_text16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16be: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16le: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub vmprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub overload_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub prepare_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub clear_bindings: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub create_module_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_close: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int, + >, + pub blob_read: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_write: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub create_collation_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub file_control: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub memory_highwater: + ::std::option::Option sqlite3_int64>, + pub memory_used: ::std::option::Option sqlite3_int64>, + pub mutex_alloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub mutex_enter: ::std::option::Option, + pub mutex_free: ::std::option::Option, + pub mutex_leave: ::std::option::Option, + pub mutex_try: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub open_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub release_memory: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub result_error_nomem: ::std::option::Option, + pub result_error_toobig: + ::std::option::Option, + pub sleep: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub soft_heap_limit: ::std::option::Option, + pub vfs_find: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, + >, + pub vfs_register: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub vfs_unregister: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, + >, + pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, + pub result_zeroblob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_error_code: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub test_control: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, + >, + pub randomness: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), + >, + pub context_db_handle: + ::std::option::Option *mut sqlite3>, + pub extended_result_codes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub limit: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub next_stmt: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, + >, + pub sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, + >, + pub status: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub backup_finish: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_init: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, + ) -> *mut sqlite3_backup, + >, + pub backup_pagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_remaining: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_step: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub compileoption_get: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, + >, + pub compileoption_used: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub create_function_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub db_config: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int, + >, + pub db_mutex: + ::std::option::Option *mut sqlite3_mutex>, + pub db_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub extended_errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub log: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char, ...), + >, + pub soft_heap_limit64: + ::std::option::Option sqlite3_int64>, + pub sourceid: ::std::option::Option *const ::std::os::raw::c_char>, + pub stmt_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub strnicmp: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub unlock_notify: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub wal_autocheckpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub wal_checkpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub wal_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub blob_reopen: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob, arg2: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub vtab_config: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int, + >, + pub vtab_on_conflict: + ::std::option::Option ::std::os::raw::c_int>, + pub close_v2: + ::std::option::Option ::std::os::raw::c_int>, + pub db_filename: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, + pub db_readonly: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub db_release_memory: + ::std::option::Option ::std::os::raw::c_int>, + pub errstr: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, + >, + pub stmt_busy: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub stmt_readonly: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub stricmp: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub uri_boolean: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub uri_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64, + ) -> sqlite3_int64, + >, + pub uri_parameter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, + pub vsnprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub wal_checkpoint_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub auto_extension: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_blob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + arg6: ::std::os::raw::c_uchar, + ) -> ::std::os::raw::c_int, + >, + pub cancel_auto_extension: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub load_extension: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub malloc64: ::std::option::Option< + unsafe extern "C" fn(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void, + >, + pub msize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64, + >, + pub realloc64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_uint64, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset_auto_extension: ::std::option::Option, + pub result_blob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + ), + >, + pub result_text64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + arg5: ::std::os::raw::c_uchar, + ), + >, + pub strglob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub value_dup: ::std::option::Option< + unsafe extern "C" fn(arg1: *const sqlite3_value) -> *mut sqlite3_value, + >, + pub value_free: ::std::option::Option, + pub result_zeroblob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: sqlite3_uint64, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_uint64, + ) -> ::std::os::raw::c_int, + >, + pub value_subtype: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint, + >, + pub result_subtype: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint), + >, + pub status64: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut sqlite3_int64, + arg3: *mut sqlite3_int64, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub strlike: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_uint, + ) -> ::std::os::raw::c_int, + >, + pub db_cacheflush: + ::std::option::Option ::std::os::raw::c_int>, + pub system_errno: + ::std::option::Option ::std::os::raw::c_int>, +} +#[test] +fn bindgen_test_layout_sqlite3_api_routines() { + assert_eq!( + ::std::mem::size_of::(), + 1712usize, + concat!("Size of: ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_context as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_context) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_count as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_double as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_count as *const _ + as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_index as *const _ + as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_index) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_name as *const _ + as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text16 as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_handler as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_handler) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_timeout as *const _ as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_timeout) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed as *const _ as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_blob as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes as *const _ as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize + }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_count as *const _ as usize + }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name as *const _ + as usize + }, + 184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name16 as *const _ + as usize + }, + 192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype as *const _ as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize + }, + 208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_double as *const _ as usize + }, + 216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, + 224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_int64 as *const _ as usize + }, + 232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name as *const _ as usize + }, + 240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name16 as *const _ as usize + }, + 248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name as *const _ as usize + }, + 256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name16 as *const _ + as usize + }, + 264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name as *const _ as usize + }, + 272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name16 as *const _ + as usize + }, + 280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text as *const _ as usize + }, + 288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text16 as *const _ as usize + }, + 296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_type as *const _ as usize + }, + 304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_type) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_value as *const _ as usize + }, + 312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).commit_hook as *const _ as usize + }, + 320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(commit_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, + 328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, + 336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation as *const _ as usize + }, + 344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation16 as *const _ as usize + }, + 352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function as *const _ as usize + }, + 360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function16 as *const _ as usize + }, + 368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module as *const _ as usize + }, + 376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, + 384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(data_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, + 392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).declare_vtab as *const _ as usize + }, + 400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(declare_vtab) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).enable_shared_cache as *const _ + as usize + }, + 408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(enable_shared_cache) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, + 416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, + 424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, + 432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, + 440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(exec) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, + 448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(expired) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, + 456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(finalize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, + 464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, + 472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_autocommit as *const _ as usize + }, + 480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_autocommit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_auxdata as *const _ as usize + }, + 488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, + 496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).global_recover as *const _ as usize + }, + 504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(global_recover) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, + 512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(interruptx) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize + }, + 520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(last_insert_rowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, + 528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).libversion_number as *const _ as usize + }, + 536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion_number) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, + 544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, + 552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, + 560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, + 568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, + 576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, + 584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, + 592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(profile) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).progress_handler as *const _ as usize + }, + 600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(progress_handler) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, + 608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, + 616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob as *const _ as usize + }, + 624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_double as *const _ as usize + }, + 632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_double) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error as *const _ as usize + }, + 640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error16 as *const _ as usize + }, + 648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, + 656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_int64 as *const _ as usize + }, + 664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_null as *const _ as usize + }, + 672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text as *const _ as usize + }, + 680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16 as *const _ as usize + }, + 688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16be as *const _ as usize + }, + 696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16le as *const _ as usize + }, + 704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16le) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_value as *const _ as usize + }, + 712usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rollback_hook as *const _ as usize + }, + 720usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(rollback_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_authorizer as *const _ as usize + }, + 728usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_authorizer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_auxdata as *const _ as usize + }, + 736usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).snprintf as *const _ as usize }, + 744usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(snprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, + 752usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).table_column_metadata as *const _ + as usize + }, + 760usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(table_column_metadata) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize + }, + 768usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(thread_cleanup) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).total_changes as *const _ as usize + }, + 776usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(total_changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, + 784usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(trace) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize + }, + 792usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(transfer_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).update_hook as *const _ as usize + }, + 800usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(update_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, + 808usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(user_data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, + 816usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes as *const _ as usize + }, + 824usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize + }, + 832usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_double as *const _ as usize + }, + 840usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, + 848usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_int64 as *const _ as usize + }, + 856usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize + }, + 864usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_numeric_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, + 872usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16 as *const _ as usize + }, + 880usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16be as *const _ as usize + }, + 888usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16le as *const _ as usize + }, + 896usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16le) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, + 904usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, + 912usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vmprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).overload_function as *const _ as usize + }, + 920usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(overload_function) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, + 928usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize + }, + 936usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).clear_bindings as *const _ as usize + }, + 944usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(clear_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize + }, + 952usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize + }, + 960usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, + 968usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_bytes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, + 976usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_close) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, + 984usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, + 992usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_read) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, + 1000usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_write) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation_v2 as *const _ + as usize + }, + 1008usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).file_control as *const _ as usize + }, + 1016usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(file_control) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_highwater as *const _ as usize + }, + 1024usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_highwater) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_used as *const _ as usize + }, + 1032usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize + }, + 1040usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_alloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_enter as *const _ as usize + }, + 1048usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_enter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, + 1056usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_leave as *const _ as usize + }, + 1064usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_leave) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, + 1072usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_try) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, + 1080usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).release_memory as *const _ as usize + }, + 1088usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(release_memory) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize + }, + 1096usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_nomem) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_toobig as *const _ + as usize + }, + 1104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_toobig) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, + 1112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sleep) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize + }, + 1120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, + 1128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_find) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_register as *const _ as usize + }, + 1136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_register) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize + }, + 1144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_unregister) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize + }, + 1152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xthreadsafe) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize + }, + 1160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_code as *const _ as usize + }, + 1168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_code) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).test_control as *const _ as usize + }, + 1176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(test_control) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, + 1184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(randomness) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).context_db_handle as *const _ as usize + }, + 1192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(context_db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_result_codes as *const _ + as usize + }, + 1200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_result_codes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, + 1208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, + 1216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(next_stmt) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, + 1224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sql) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, + 1232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_finish as *const _ as usize + }, + 1240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_finish) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_init as *const _ as usize + }, + 1248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_init) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_pagecount as *const _ as usize + }, + 1256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_pagecount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_remaining as *const _ as usize + }, + 1264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_remaining) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_step as *const _ as usize + }, + 1272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_get as *const _ as usize + }, + 1280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_get) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_used as *const _ as usize + }, + 1288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function_v2 as *const _ as usize + }, + 1296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function_v2) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_config as *const _ as usize }, + 1304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_config) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_mutex as *const _ as usize }, + 1312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_mutex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_status as *const _ as usize }, + 1320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_errcode as *const _ as usize + }, + 1328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).log as *const _ as usize }, + 1336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(log) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit64 as *const _ as usize + }, + 1344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sourceid as *const _ as usize }, + 1352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sourceid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stmt_status as *const _ as usize + }, + 1360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_status) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strnicmp as *const _ as usize }, + 1368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strnicmp) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).unlock_notify as *const _ as usize + }, + 1376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(unlock_notify) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_autocheckpoint as *const _ as usize + }, + 1384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_autocheckpoint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_checkpoint as *const _ as usize + }, + 1392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_checkpoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).wal_hook as *const _ as usize }, + 1400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).blob_reopen as *const _ as usize + }, + 1408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_reopen) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_config as *const _ as usize + }, + 1416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_config) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_on_conflict as *const _ as usize + }, + 1424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_on_conflict) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close_v2 as *const _ as usize }, + 1432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_filename as *const _ as usize + }, + 1440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_filename) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_readonly as *const _ as usize + }, + 1448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_readonly) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_release_memory as *const _ as usize + }, + 1456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_release_memory) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errstr as *const _ as usize }, + 1464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errstr) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).stmt_busy as *const _ as usize }, + 1472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_busy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stmt_readonly as *const _ as usize + }, + 1480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_readonly) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).stricmp as *const _ as usize }, + 1488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stricmp) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).uri_boolean as *const _ as usize + }, + 1496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_boolean) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).uri_int64 as *const _ as usize }, + 1504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).uri_parameter as *const _ as usize + }, + 1512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_parameter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vsnprintf as *const _ as usize }, + 1520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vsnprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_checkpoint_v2 as *const _ as usize + }, + 1528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_checkpoint_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).auto_extension as *const _ as usize + }, + 1536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(auto_extension) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_blob64 as *const _ as usize + }, + 1544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text64 as *const _ as usize + }, + 1552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).cancel_auto_extension as *const _ + as usize + }, + 1560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(cancel_auto_extension) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).load_extension as *const _ as usize + }, + 1568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(load_extension) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc64 as *const _ as usize }, + 1576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).msize as *const _ as usize }, + 1584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(msize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc64 as *const _ as usize }, + 1592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).reset_auto_extension as *const _ + as usize + }, + 1600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset_auto_extension) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob64 as *const _ as usize + }, + 1608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text64 as *const _ as usize + }, + 1616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strglob as *const _ as usize }, + 1624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strglob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_dup as *const _ as usize }, + 1632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_dup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_free as *const _ as usize }, + 1640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob64 as *const _ as usize + }, + 1648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob64 as *const _ as usize + }, + 1656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_subtype as *const _ as usize + }, + 1664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_subtype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_subtype as *const _ as usize + }, + 1672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_subtype) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status64 as *const _ as usize }, + 1680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strlike as *const _ as usize }, + 1688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strlike) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_cacheflush as *const _ as usize + }, + 1696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_cacheflush) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).system_errno as *const _ as usize + }, + 1704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(system_errno) + ) + ); +} +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} + +// bindings were built with (non-embedded) loadable_extension: +// we define our own sqlite_api static variable and export it +// to C +#[no_mangle] +pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_routines; + +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) + +pub unsafe fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_context.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_context", + " function" + )))(arg1, nBytes) +} + +pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_double", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_null", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_index.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_index", + " function" + )))(arg1, zName) +} + +pub unsafe fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_value", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_handler", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_timeout.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_timeout", + " function" + )))(arg1, ms) +} + +pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_blob", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype", + " function" + )))(arg1, i) +} + +pub unsafe fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_double", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int64", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_type", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_value", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).commit_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "commit_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete16", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_create_collation( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_collation16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_function( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_function16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function16", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_module( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).data_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "data_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).declare_vtab.expect(stringify!( + "sqlite3_api contains null pointer for ", + "declare_vtab", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).enable_shared_cache.expect(stringify!( + "sqlite3_api contains null pointer for ", + "enable_shared_cache", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errcode", + " function" + )))(db) +} + +pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_exec( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).exec.expect(stringify!( + "sqlite3_api contains null pointer for ", + "exec", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).expired.expect(stringify!( + "sqlite3_api contains null pointer for ", + "expired", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).finalize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "finalize", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free_table", + " function" + )))(result) +} + +pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_autocommit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_autocommit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_auxdata", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_get_table( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_table", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).global_recover.expect(stringify!( + "sqlite3_api contains null pointer for ", + "global_recover", + " function" + )))() +} + +pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).interruptx.expect(stringify!( + "sqlite3_api contains null pointer for ", + "interruptx", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).last_insert_rowid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "last_insert_rowid", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion", + " function" + )))() +} + +pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion_number.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion_number", + " function" + )))() +} + +pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mprintf( + arg1: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mprintf", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_open( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_open16( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_prepare( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_profile( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).profile.expect(stringify!( + "sqlite3_api contains null pointer for ", + "profile", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).progress_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "progress_handler", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_double", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_null", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16be", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16le", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_value", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).rollback_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "rollback_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_authorizer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_authorizer", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_auxdata", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_snprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).snprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "snprintf", + " function" + )))(arg1, arg2, arg3, vararg1) +} + +pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "step", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_table_column_metadata( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).table_column_metadata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "table_column_metadata", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) +} + +pub unsafe fn sqlite3_thread_cleanup() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).thread_cleanup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "thread_cleanup", + " function" + )))() +} + +pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).total_changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "total_changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).trace.expect(stringify!( + "sqlite3_api contains null pointer for ", + "trace", + " function" + )))(arg1, xTrace, arg2) +} + +pub unsafe fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).transfer_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "transfer_bindings", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).update_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "update_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).user_data.expect(stringify!( + "sqlite3_api contains null pointer for ", + "user_data", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_blob", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_double", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_numeric_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_numeric_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16be", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16le", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vmprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vmprintf", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).overload_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "overload_function", + " function" + )))(arg1, zFuncName, nArg) +} + +pub unsafe fn sqlite3_prepare_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).clear_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "clear_bindings", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_module_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module_v2", + " function" + )))(arg1, arg2, arg3, arg4, xDestroy) +} + +pub unsafe fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_open( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_open", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) +} + +pub unsafe fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_read.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_read", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_write.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_write", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_file_control( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).file_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "file_control", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_highwater.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_highwater", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_used", + " function" + )))() +} + +pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_alloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_alloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_enter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_enter", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_leave.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_leave", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_try.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_try", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_open_v2( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open_v2", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_nomem.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_nomem", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_toobig.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_toobig", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sleep.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sleep", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_find.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_find", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_register.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_register", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_unregister.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_unregister", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xthreadsafe.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xthreadsafe", + " function" + )))() +} + +pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_code.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_code", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_test_control( + arg1: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).test_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "test_control", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).randomness.expect(stringify!( + "sqlite3_api contains null pointer for ", + "randomness", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).context_db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "context_db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_result_codes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_result_codes", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_limit( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "limit", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).next_stmt.expect(stringify!( + "sqlite3_api contains null pointer for ", + "next_stmt", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_status( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_finish.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_finish", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_init( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, +) -> *mut sqlite3_backup { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_init.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_init", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_pagecount.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_pagecount", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_remaining.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_remaining", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_step( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_step", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_compileoption_get( + arg1: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_get.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_get", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_compileoption_used( + arg1: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_used", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_function_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal, xDestroy) +} + +pub unsafe fn sqlite3_db_config( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, + vararg2: &mut i32, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_config", + " function" + )))(arg1, arg2, vararg1, vararg2) +} + +pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_mutex.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_mutex", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_db_status( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_status", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_errcode", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_log( + arg1: ::std::os::raw::c_int, + arg2: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).log.expect(stringify!( + "sqlite3_api contains null pointer for ", + "log", + " function" + )))(arg1, arg2, vararg1) +} + +pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sourceid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sourceid", + " function" + )))() +} + +pub unsafe fn sqlite3_stmt_status( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_status", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_strnicmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strnicmp.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strnicmp", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_unlock_notify( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int), + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).unlock_notify.expect(stringify!( + "sqlite3_api contains null pointer for ", + "unlock_notify", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_wal_autocheckpoint( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_autocheckpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_checkpoint( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_checkpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_checkpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_reopen( + arg1: *mut sqlite3_blob, + arg2: sqlite3_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_reopen.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_reopen", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vtab_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_config", + " function" + )))(arg1, op, vararg1) +} + +pub unsafe fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_on_conflict.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_on_conflict", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close_v2", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_db_filename( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_filename.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_filename", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_db_readonly( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_readonly.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_readonly", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errstr.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errstr", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_busy.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_busy", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stmt_readonly(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_readonly.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_readonly", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stricmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stricmp.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stricmp", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_uri_boolean( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_boolean.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_boolean", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_uri_int64( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64, +) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_uri_parameter( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_parameter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_parameter", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vsnprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vsnprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vsnprintf", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_wal_checkpoint_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_checkpoint_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_checkpoint_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_auto_extension( + arg1: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).auto_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "auto_extension", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob64", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_text64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + arg6: ::std::os::raw::c_uchar, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text64", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_cancel_auto_extension( + arg1: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).cancel_auto_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "cancel_auto_extension", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_load_extension( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).load_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "load_extension", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_malloc64(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_msize(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).msize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "msize", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_realloc64( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_uint64, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset_auto_extension() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset_auto_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset_auto_extension", + " function" + )))() +} + +pub unsafe fn sqlite3_result_blob64( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob64", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text64( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + arg5: ::std::os::raw::c_uchar, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text64", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_strglob( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strglob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strglob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_value_dup(arg1: *const sqlite3_value) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_dup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_dup", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_free(arg1: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_zeroblob64( + arg1: *mut sqlite3_context, + arg2: sqlite3_uint64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_zeroblob64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_uint64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_value_subtype(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_subtype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_subtype", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_subtype(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_subtype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_subtype", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_status64( + arg1: ::std::os::raw::c_int, + arg2: *mut sqlite3_int64, + arg3: *mut sqlite3_int64, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status64", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_strlike( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_uint, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strlike.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strlike", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_db_cacheflush(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_cacheflush.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_cacheflush", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_system_errno(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).system_errno.expect(stringify!( + "sqlite3_api contains null pointer for ", + "system_errno", + " function" + )))(arg1) +} diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.13.0.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.13.0.rs new file mode 100644 index 000000000..f375d2efb --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.13.0.rs @@ -0,0 +1,4954 @@ +/* automatically generated by rust-bindgen */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.13.0\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3013000; +pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = + b"2016-05-18 10:57:30 fc49f556e48970561d7ab6a2f24fdd7d9eb81ff2\0"; +pub const SQLITE_OK: i32 = 0; +pub const SQLITE_ERROR: i32 = 1; +pub const SQLITE_INTERNAL: i32 = 2; +pub const SQLITE_PERM: i32 = 3; +pub const SQLITE_ABORT: i32 = 4; +pub const SQLITE_BUSY: i32 = 5; +pub const SQLITE_LOCKED: i32 = 6; +pub const SQLITE_NOMEM: i32 = 7; +pub const SQLITE_READONLY: i32 = 8; +pub const SQLITE_INTERRUPT: i32 = 9; +pub const SQLITE_IOERR: i32 = 10; +pub const SQLITE_CORRUPT: i32 = 11; +pub const SQLITE_NOTFOUND: i32 = 12; +pub const SQLITE_FULL: i32 = 13; +pub const SQLITE_CANTOPEN: i32 = 14; +pub const SQLITE_PROTOCOL: i32 = 15; +pub const SQLITE_EMPTY: i32 = 16; +pub const SQLITE_SCHEMA: i32 = 17; +pub const SQLITE_TOOBIG: i32 = 18; +pub const SQLITE_CONSTRAINT: i32 = 19; +pub const SQLITE_MISMATCH: i32 = 20; +pub const SQLITE_MISUSE: i32 = 21; +pub const SQLITE_NOLFS: i32 = 22; +pub const SQLITE_AUTH: i32 = 23; +pub const SQLITE_FORMAT: i32 = 24; +pub const SQLITE_RANGE: i32 = 25; +pub const SQLITE_NOTADB: i32 = 26; +pub const SQLITE_NOTICE: i32 = 27; +pub const SQLITE_WARNING: i32 = 28; +pub const SQLITE_ROW: i32 = 100; +pub const SQLITE_DONE: i32 = 101; +pub const SQLITE_IOERR_READ: i32 = 266; +pub const SQLITE_IOERR_SHORT_READ: i32 = 522; +pub const SQLITE_IOERR_WRITE: i32 = 778; +pub const SQLITE_IOERR_FSYNC: i32 = 1034; +pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; +pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; +pub const SQLITE_IOERR_FSTAT: i32 = 1802; +pub const SQLITE_IOERR_UNLOCK: i32 = 2058; +pub const SQLITE_IOERR_RDLOCK: i32 = 2314; +pub const SQLITE_IOERR_DELETE: i32 = 2570; +pub const SQLITE_IOERR_BLOCKED: i32 = 2826; +pub const SQLITE_IOERR_NOMEM: i32 = 3082; +pub const SQLITE_IOERR_ACCESS: i32 = 3338; +pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; +pub const SQLITE_IOERR_LOCK: i32 = 3850; +pub const SQLITE_IOERR_CLOSE: i32 = 4106; +pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; +pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; +pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; +pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; +pub const SQLITE_IOERR_SHMMAP: i32 = 5386; +pub const SQLITE_IOERR_SEEK: i32 = 5642; +pub const SQLITE_IOERR_DELETE_NOENT: i32 = 5898; +pub const SQLITE_IOERR_MMAP: i32 = 6154; +pub const SQLITE_IOERR_GETTEMPPATH: i32 = 6410; +pub const SQLITE_IOERR_CONVPATH: i32 = 6666; +pub const SQLITE_IOERR_VNODE: i32 = 6922; +pub const SQLITE_IOERR_AUTH: i32 = 7178; +pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; +pub const SQLITE_BUSY_RECOVERY: i32 = 261; +pub const SQLITE_BUSY_SNAPSHOT: i32 = 517; +pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; +pub const SQLITE_CANTOPEN_ISDIR: i32 = 526; +pub const SQLITE_CANTOPEN_FULLPATH: i32 = 782; +pub const SQLITE_CANTOPEN_CONVPATH: i32 = 1038; +pub const SQLITE_CORRUPT_VTAB: i32 = 267; +pub const SQLITE_READONLY_RECOVERY: i32 = 264; +pub const SQLITE_READONLY_CANTLOCK: i32 = 520; +pub const SQLITE_READONLY_ROLLBACK: i32 = 776; +pub const SQLITE_READONLY_DBMOVED: i32 = 1032; +pub const SQLITE_ABORT_ROLLBACK: i32 = 516; +pub const SQLITE_CONSTRAINT_CHECK: i32 = 275; +pub const SQLITE_CONSTRAINT_COMMITHOOK: i32 = 531; +pub const SQLITE_CONSTRAINT_FOREIGNKEY: i32 = 787; +pub const SQLITE_CONSTRAINT_FUNCTION: i32 = 1043; +pub const SQLITE_CONSTRAINT_NOTNULL: i32 = 1299; +pub const SQLITE_CONSTRAINT_PRIMARYKEY: i32 = 1555; +pub const SQLITE_CONSTRAINT_TRIGGER: i32 = 1811; +pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067; +pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323; +pub const SQLITE_CONSTRAINT_ROWID: i32 = 2579; +pub const SQLITE_NOTICE_RECOVER_WAL: i32 = 283; +pub const SQLITE_NOTICE_RECOVER_ROLLBACK: i32 = 539; +pub const SQLITE_WARNING_AUTOINDEX: i32 = 284; +pub const SQLITE_AUTH_USER: i32 = 279; +pub const SQLITE_OPEN_READONLY: i32 = 1; +pub const SQLITE_OPEN_READWRITE: i32 = 2; +pub const SQLITE_OPEN_CREATE: i32 = 4; +pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; +pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; +pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; +pub const SQLITE_OPEN_URI: i32 = 64; +pub const SQLITE_OPEN_MEMORY: i32 = 128; +pub const SQLITE_OPEN_MAIN_DB: i32 = 256; +pub const SQLITE_OPEN_TEMP_DB: i32 = 512; +pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; +pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; +pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; +pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; +pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; +pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; +pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; +pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; +pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; +pub const SQLITE_OPEN_WAL: i32 = 524288; +pub const SQLITE_IOCAP_ATOMIC: i32 = 1; +pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; +pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; +pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; +pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; +pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; +pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; +pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; +pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; +pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; +pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; +pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; +pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE: i32 = 4096; +pub const SQLITE_IOCAP_IMMUTABLE: i32 = 8192; +pub const SQLITE_LOCK_NONE: i32 = 0; +pub const SQLITE_LOCK_SHARED: i32 = 1; +pub const SQLITE_LOCK_RESERVED: i32 = 2; +pub const SQLITE_LOCK_PENDING: i32 = 3; +pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; +pub const SQLITE_SYNC_NORMAL: i32 = 2; +pub const SQLITE_SYNC_FULL: i32 = 3; +pub const SQLITE_SYNC_DATAONLY: i32 = 16; +pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; +pub const SQLITE_FCNTL_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_FCNTL_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_FCNTL_LAST_ERRNO: i32 = 4; +pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; +pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; +pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; +pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; +pub const SQLITE_FCNTL_WIN32_AV_RETRY: i32 = 9; +pub const SQLITE_FCNTL_PERSIST_WAL: i32 = 10; +pub const SQLITE_FCNTL_OVERWRITE: i32 = 11; +pub const SQLITE_FCNTL_VFSNAME: i32 = 12; +pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE: i32 = 13; +pub const SQLITE_FCNTL_PRAGMA: i32 = 14; +pub const SQLITE_FCNTL_BUSYHANDLER: i32 = 15; +pub const SQLITE_FCNTL_TEMPFILENAME: i32 = 16; +pub const SQLITE_FCNTL_MMAP_SIZE: i32 = 18; +pub const SQLITE_FCNTL_TRACE: i32 = 19; +pub const SQLITE_FCNTL_HAS_MOVED: i32 = 20; +pub const SQLITE_FCNTL_SYNC: i32 = 21; +pub const SQLITE_FCNTL_COMMIT_PHASETWO: i32 = 22; +pub const SQLITE_FCNTL_WIN32_SET_HANDLE: i32 = 23; +pub const SQLITE_FCNTL_WAL_BLOCK: i32 = 24; +pub const SQLITE_FCNTL_ZIPVFS: i32 = 25; +pub const SQLITE_FCNTL_RBU: i32 = 26; +pub const SQLITE_FCNTL_VFS_POINTER: i32 = 27; +pub const SQLITE_FCNTL_JOURNAL_POINTER: i32 = 28; +pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_LAST_ERRNO: i32 = 4; +pub const SQLITE_ACCESS_EXISTS: i32 = 0; +pub const SQLITE_ACCESS_READWRITE: i32 = 1; +pub const SQLITE_ACCESS_READ: i32 = 2; +pub const SQLITE_SHM_UNLOCK: i32 = 1; +pub const SQLITE_SHM_LOCK: i32 = 2; +pub const SQLITE_SHM_SHARED: i32 = 4; +pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; +pub const SQLITE_SHM_NLOCK: i32 = 8; +pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; +pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; +pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; +pub const SQLITE_CONFIG_MALLOC: i32 = 4; +pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; +pub const SQLITE_CONFIG_SCRATCH: i32 = 6; +pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; +pub const SQLITE_CONFIG_HEAP: i32 = 8; +pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; +pub const SQLITE_CONFIG_MUTEX: i32 = 10; +pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; +pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; +pub const SQLITE_CONFIG_PCACHE: i32 = 14; +pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; +pub const SQLITE_CONFIG_LOG: i32 = 16; +pub const SQLITE_CONFIG_URI: i32 = 17; +pub const SQLITE_CONFIG_PCACHE2: i32 = 18; +pub const SQLITE_CONFIG_GETPCACHE2: i32 = 19; +pub const SQLITE_CONFIG_COVERING_INDEX_SCAN: i32 = 20; +pub const SQLITE_CONFIG_SQLLOG: i32 = 21; +pub const SQLITE_CONFIG_MMAP_SIZE: i32 = 22; +pub const SQLITE_CONFIG_WIN32_HEAPSIZE: i32 = 23; +pub const SQLITE_CONFIG_PCACHE_HDRSZ: i32 = 24; +pub const SQLITE_CONFIG_PMASZ: i32 = 25; +pub const SQLITE_CONFIG_STMTJRNL_SPILL: i32 = 26; +pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; +pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; +pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; +pub const SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: i32 = 1004; +pub const SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: i32 = 1005; +pub const SQLITE_DENY: i32 = 1; +pub const SQLITE_IGNORE: i32 = 2; +pub const SQLITE_CREATE_INDEX: i32 = 1; +pub const SQLITE_CREATE_TABLE: i32 = 2; +pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; +pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; +pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; +pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; +pub const SQLITE_CREATE_TRIGGER: i32 = 7; +pub const SQLITE_CREATE_VIEW: i32 = 8; +pub const SQLITE_DELETE: i32 = 9; +pub const SQLITE_DROP_INDEX: i32 = 10; +pub const SQLITE_DROP_TABLE: i32 = 11; +pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; +pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; +pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; +pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; +pub const SQLITE_DROP_TRIGGER: i32 = 16; +pub const SQLITE_DROP_VIEW: i32 = 17; +pub const SQLITE_INSERT: i32 = 18; +pub const SQLITE_PRAGMA: i32 = 19; +pub const SQLITE_READ: i32 = 20; +pub const SQLITE_SELECT: i32 = 21; +pub const SQLITE_TRANSACTION: i32 = 22; +pub const SQLITE_UPDATE: i32 = 23; +pub const SQLITE_ATTACH: i32 = 24; +pub const SQLITE_DETACH: i32 = 25; +pub const SQLITE_ALTER_TABLE: i32 = 26; +pub const SQLITE_REINDEX: i32 = 27; +pub const SQLITE_ANALYZE: i32 = 28; +pub const SQLITE_CREATE_VTABLE: i32 = 29; +pub const SQLITE_DROP_VTABLE: i32 = 30; +pub const SQLITE_FUNCTION: i32 = 31; +pub const SQLITE_SAVEPOINT: i32 = 32; +pub const SQLITE_COPY: i32 = 0; +pub const SQLITE_RECURSIVE: i32 = 33; +pub const SQLITE_LIMIT_LENGTH: i32 = 0; +pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; +pub const SQLITE_LIMIT_COLUMN: i32 = 2; +pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; +pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; +pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; +pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; +pub const SQLITE_LIMIT_ATTACHED: i32 = 7; +pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; +pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; +pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; +pub const SQLITE_LIMIT_WORKER_THREADS: i32 = 11; +pub const SQLITE_INTEGER: i32 = 1; +pub const SQLITE_FLOAT: i32 = 2; +pub const SQLITE_BLOB: i32 = 4; +pub const SQLITE_NULL: i32 = 5; +pub const SQLITE_TEXT: i32 = 3; +pub const SQLITE3_TEXT: i32 = 3; +pub const SQLITE_UTF8: i32 = 1; +pub const SQLITE_UTF16LE: i32 = 2; +pub const SQLITE_UTF16BE: i32 = 3; +pub const SQLITE_UTF16: i32 = 4; +pub const SQLITE_ANY: i32 = 5; +pub const SQLITE_UTF16_ALIGNED: i32 = 8; +pub const SQLITE_DETERMINISTIC: i32 = 2048; +pub const SQLITE_INDEX_SCAN_UNIQUE: i32 = 1; +pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; +pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; +pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; +pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; +pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; +pub const SQLITE_INDEX_CONSTRAINT_LIKE: i32 = 65; +pub const SQLITE_INDEX_CONSTRAINT_GLOB: i32 = 66; +pub const SQLITE_INDEX_CONSTRAINT_REGEXP: i32 = 67; +pub const SQLITE_MUTEX_FAST: i32 = 0; +pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; +pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; +pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; +pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; +pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; +pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; +pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; +pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; +pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; +pub const SQLITE_MUTEX_STATIC_APP1: i32 = 8; +pub const SQLITE_MUTEX_STATIC_APP2: i32 = 9; +pub const SQLITE_MUTEX_STATIC_APP3: i32 = 10; +pub const SQLITE_MUTEX_STATIC_VFS1: i32 = 11; +pub const SQLITE_MUTEX_STATIC_VFS2: i32 = 12; +pub const SQLITE_MUTEX_STATIC_VFS3: i32 = 13; +pub const SQLITE_TESTCTRL_FIRST: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; +pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; +pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; +pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; +pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; +pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; +pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; +pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; +pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; +pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; +pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; +pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 17; +pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 18; +pub const SQLITE_TESTCTRL_EXPLAIN_STMT: i32 = 19; +pub const SQLITE_TESTCTRL_NEVER_CORRUPT: i32 = 20; +pub const SQLITE_TESTCTRL_VDBE_COVERAGE: i32 = 21; +pub const SQLITE_TESTCTRL_BYTEORDER: i32 = 22; +pub const SQLITE_TESTCTRL_ISINIT: i32 = 23; +pub const SQLITE_TESTCTRL_SORTER_MMAP: i32 = 24; +pub const SQLITE_TESTCTRL_IMPOSTER: i32 = 25; +pub const SQLITE_TESTCTRL_LAST: i32 = 25; +pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; +pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; +pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; +pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; +pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; +pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; +pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; +pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; +pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; +pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; +pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; +pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; +pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; +pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; +pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; +pub const SQLITE_DBSTATUS_CACHE_HIT: i32 = 7; +pub const SQLITE_DBSTATUS_CACHE_MISS: i32 = 8; +pub const SQLITE_DBSTATUS_CACHE_WRITE: i32 = 9; +pub const SQLITE_DBSTATUS_DEFERRED_FKS: i32 = 10; +pub const SQLITE_DBSTATUS_MAX: i32 = 10; +pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; +pub const SQLITE_STMTSTATUS_SORT: i32 = 2; +pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; +pub const SQLITE_STMTSTATUS_VM_STEP: i32 = 4; +pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; +pub const SQLITE_CHECKPOINT_FULL: i32 = 1; +pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; +pub const SQLITE_CHECKPOINT_TRUNCATE: i32 = 3; +pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; +pub const SQLITE_ROLLBACK: i32 = 1; +pub const SQLITE_FAIL: i32 = 3; +pub const SQLITE_REPLACE: i32 = 5; +pub const SQLITE_SCANSTAT_NLOOP: i32 = 0; +pub const SQLITE_SCANSTAT_NVISIT: i32 = 1; +pub const SQLITE_SCANSTAT_EST: i32 = 2; +pub const SQLITE_SCANSTAT_NAME: i32 = 3; +pub const SQLITE_SCANSTAT_EXPLAIN: i32 = 4; +pub const SQLITE_SCANSTAT_SELECTID: i32 = 5; +pub const NOT_WITHIN: i32 = 0; +pub const PARTLY_WITHIN: i32 = 1; +pub const FULLY_WITHIN: i32 = 2; +pub const FTS5_TOKENIZE_QUERY: i32 = 1; +pub const FTS5_TOKENIZE_PREFIX: i32 = 2; +pub const FTS5_TOKENIZE_DOCUMENT: i32 = 4; +pub const FTS5_TOKENIZE_AUX: i32 = 8; +pub const FTS5_TOKEN_COLOCATED: i32 = 1; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; +extern "C" { + #[link_name = "\u{1}sqlite3_version"] + pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; +} +extern "C" { + pub fn sqlite3_libversion() -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_sourceid() -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_libversion_number() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_compileoption_used( + zOptName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_compileoption_get(N: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_threadsafe() -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3 { + _unused: [u8; 0], +} +pub type sqlite_int64 = ::std::os::raw::c_longlong; +pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; +pub type sqlite3_int64 = sqlite_int64; +pub type sqlite3_uint64 = sqlite_uint64; +extern "C" { + pub fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +extern "C" { + pub fn sqlite3_exec( + arg1: *mut sqlite3, + sql: *const ::std::os::raw::c_char, + callback: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg2: *mut ::std::os::raw::c_void, + errmsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_file { + pub pMethods: *const sqlite3_io_methods, +} +#[test] +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xShmMap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iPg: ::std::os::raw::c_int, + pgsz: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xShmLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + offset: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xShmBarrier: ::std::option::Option, + pub xShmUnmap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + deleteFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iOfst: sqlite3_int64, + iAmt: ::std::os::raw::c_int, + pp: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xUnfetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iOfst: sqlite3_int64, + p: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 152usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmMap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmBarrier) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmUnmap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnfetch as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnfetch) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +pub type sqlite3_syscall_ptr = ::std::option::Option; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vfs { + pub iVersion: ::std::os::raw::c_int, + pub szOsFile: ::std::os::raw::c_int, + pub mxPathname: ::std::os::raw::c_int, + pub pNext: *mut sqlite3_vfs, + pub zName: *const ::std::os::raw::c_char, + pub pAppData: *mut ::std::os::raw::c_void, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTimeInt64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xSetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: sqlite3_syscall_ptr, + ) -> ::std::os::raw::c_int, + >, + pub xGetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> sqlite3_syscall_ptr, + >, + pub xNextSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_vfs() { + assert_eq!( + ::std::mem::size_of::(), + 168usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTimeInt64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xNextSystemCall) + ) + ); +} +extern "C" { + pub fn sqlite3_initialize() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_shutdown() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_os_init() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_os_end() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_db_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mem_methods { + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub pAppData: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_mem_methods() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +extern "C" { + pub fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + onoff: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_interrupt(arg1: *mut sqlite3); +} +extern "C" { + pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_get_table( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + pazResult: *mut *mut *mut ::std::os::raw::c_char, + pnRow: *mut ::std::os::raw::c_int, + pnColumn: *mut ::std::os::raw::c_int, + pzErrmsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char); +} +extern "C" { + pub fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char, ...) + -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_snprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_vsnprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_malloc64(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_realloc64( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_uint64, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_free(arg1: *mut ::std::os::raw::c_void); +} +extern "C" { + pub fn sqlite3_msize(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64; +} +extern "C" { + pub fn sqlite3_memory_used() -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_randomness(N: ::std::os::raw::c_int, P: *mut ::std::os::raw::c_void); +} +extern "C" { + pub fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + xAuth: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pUserData: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_profile( + arg1: *mut sqlite3, + xProfile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + pub fn sqlite3_open( + filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_open16( + filename: *const ::std::os::raw::c_void, + ppDb: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_open_v2( + filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3, + flags: ::std::os::raw::c_int, + zVfs: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_uri_parameter( + zFilename: *const ::std::os::raw::c_char, + zParam: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_uri_boolean( + zFile: *const ::std::os::raw::c_char, + zParam: *const ::std::os::raw::c_char, + bDefault: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_uri_int64( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64, + ) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_extended_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_stmt { + _unused: [u8; 0], +} +extern "C" { + pub fn sqlite3_limit( + arg1: *mut sqlite3, + id: ::std::os::raw::c_int, + newVal: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_prepare( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_prepare_v2( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_prepare16( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_prepare16_v2( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_stmt_readonly(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Mem { + _unused: [u8; 0], +} +pub type sqlite3_value = Mem; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_context { + _unused: [u8; 0], +} +extern "C" { + pub fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_blob64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_int64, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_text64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + encoding: ::std::os::raw::c_uchar, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_zeroblob64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_uint64, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64; +} +extern "C" { + pub fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar; +} +extern "C" { + pub fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value; +} +extern "C" { + pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function16( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_void, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function_v2( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_global_recover() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_thread_cleanup(); +} +extern "C" { + pub fn sqlite3_memory_alarm( + arg1: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_int64, + arg3: ::std::os::raw::c_int, + ), + >, + arg2: *mut ::std::os::raw::c_void, + arg3: sqlite3_int64, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64; +} +extern "C" { + pub fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar; +} +extern "C" { + pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_subtype(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint; +} +extern "C" { + pub fn sqlite3_value_dup(arg1: *const sqlite3_value) -> *mut sqlite3_value; +} +extern "C" { + pub fn sqlite3_value_free(arg1: *mut sqlite3_value); +} +extern "C" { + pub fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3; +} +extern "C" { + pub fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option, + ); +} +pub type sqlite3_destructor_type = + ::std::option::Option; +extern "C" { + pub fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_blob64( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64); +} +extern "C" { + pub fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context); +} +extern "C" { + pub fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context); +} +extern "C" { + pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite3_int64); +} +extern "C" { + pub fn sqlite3_result_null(arg1: *mut sqlite3_context); +} +extern "C" { + pub fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text64( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + encoding: ::std::os::raw::c_uchar, + ); +} +extern "C" { + pub fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value); +} +extern "C" { + pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, n: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_result_zeroblob64( + arg1: *mut sqlite3_context, + n: sqlite3_uint64, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_result_subtype(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint); +} +extern "C" { + pub fn sqlite3_create_collation( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation16( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_void, + eTextRep: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "\u{1}sqlite3_temp_directory"] + pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "\u{1}sqlite3_data_directory"] + pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3; +} +extern "C" { + pub fn sqlite3_db_filename( + db: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_db_readonly( + db: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) -> *mut sqlite3_stmt; +} +extern "C" { + pub fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_soft_heap_limit64(N: sqlite3_int64) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_soft_heap_limit(N: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_table_column_metadata( + db: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + zTableName: *const ::std::os::raw::c_char, + zColumnName: *const ::std::os::raw::c_char, + pzDataType: *mut *const ::std::os::raw::c_char, + pzCollSeq: *mut *const ::std::os::raw::c_char, + pNotNull: *mut ::std::os::raw::c_int, + pPrimaryKey: *mut ::std::os::raw::c_int, + pAutoinc: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_load_extension( + db: *mut sqlite3, + zFile: *const ::std::os::raw::c_char, + zProc: *const ::std::os::raw::c_char, + pzErrMsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_enable_load_extension( + db: *mut sqlite3, + onoff: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_auto_extension( + xEntryPoint: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_cancel_auto_extension( + xEntryPoint: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_reset_auto_extension(); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSavepoint: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRelease: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRollbackTo: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 184usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSavepoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRelease) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollbackTo) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info { + pub nConstraint: ::std::os::raw::c_int, + pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, + pub nOrderBy: ::std::os::raw::c_int, + pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, + pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, + pub idxNum: ::std::os::raw::c_int, + pub idxStr: *mut ::std::os::raw::c_char, + pub needToFreeIdxStr: ::std::os::raw::c_int, + pub orderByConsumed: ::std::os::raw::c_int, + pub estimatedCost: f64, + pub estimatedRows: sqlite3_int64, + pub idxFlags: ::std::os::raw::c_int, + pub colUsed: sqlite3_uint64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint { + pub iColumn: ::std::os::raw::c_int, + pub op: ::std::os::raw::c_uchar, + pub usable: ::std::os::raw::c_uchar, + pub iTermOffset: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_orderby { + pub iColumn: ::std::os::raw::c_int, + pub desc: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint_usage { + pub argvIndex: ::std::os::raw::c_int, + pub omit: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); +} +#[test] +fn bindgen_test_layout_sqlite3_index_info() { + assert_eq!( + ::std::mem::size_of::(), + 96usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedRows as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedRows) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxFlags as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxFlags) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).colUsed as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(colUsed) + ) + ); +} +extern "C" { + pub fn sqlite3_create_module( + db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + p: *const sqlite3_module, + pClientData: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_module_v2( + db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + p: *const sqlite3_module, + pClientData: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +extern "C" { + pub fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + zSQL: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_blob { + _unused: [u8; 0], +} +extern "C" { + pub fn sqlite3_blob_open( + arg1: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + zTable: *const ::std::os::raw::c_char, + zColumn: *const ::std::os::raw::c_char, + iRow: sqlite3_int64, + flags: ::std::os::raw::c_int, + ppBlob: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_blob_reopen( + arg1: *mut sqlite3_blob, + arg2: sqlite3_int64, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + Z: *mut ::std::os::raw::c_void, + N: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + z: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs; +} +extern "C" { + pub fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + makeDflt: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex; +} +extern "C" { + pub fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex); +} +extern "C" { + pub fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex); +} +extern "C" { + pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex_methods { + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_mutex_methods() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +extern "C" { + pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex; +} +extern "C" { + pub fn sqlite3_file_control( + arg1: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + op: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_status( + op: ::std::os::raw::c_int, + pCurrent: *mut ::std::os::raw::c_int, + pHighwater: *mut ::std::os::raw::c_int, + resetFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_status64( + op: ::std::os::raw::c_int, + pCurrent: *mut sqlite3_int64, + pHighwater: *mut sqlite3_int64, + resetFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_db_status( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + pCur: *mut ::std::os::raw::c_int, + pHiwtr: *mut ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_stmt_status( + arg1: *mut sqlite3_stmt, + op: ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_page { + pub pBuf: *mut ::std::os::raw::c_void, + pub pExtra: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_page() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pBuf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pExtra) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods2 { + pub iVersion: ::std::os::raw::c_int, + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + szExtra: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache_page, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, + pub xShrink: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods2() { + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iVersion as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDestroy as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShrink) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods { + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_backup { + _unused: [u8; 0], +} +extern "C" { + pub fn sqlite3_backup_init( + pDest: *mut sqlite3, + zDestName: *const ::std::os::raw::c_char, + pSource: *mut sqlite3, + zSourceName: *const ::std::os::raw::c_char, + ) -> *mut sqlite3_backup; +} +extern "C" { + pub fn sqlite3_backup_step( + p: *mut sqlite3_backup, + nPage: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_backup_finish(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_backup_remaining(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_backup_pagecount(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_unlock_notify( + pBlocked: *mut sqlite3, + xNotify: ::std::option::Option< + unsafe extern "C" fn( + apArg: *mut *mut ::std::os::raw::c_void, + nArg: ::std::os::raw::c_int, + ), + >, + pNotifyArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_stricmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_strnicmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_strglob( + zGlob: *const ::std::os::raw::c_char, + zStr: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_strlike( + zGlob: *const ::std::os::raw::c_char, + zStr: *const ::std::os::raw::c_char, + cEsc: ::std::os::raw::c_uint, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_log( + iErrCode: ::std::os::raw::c_int, + zFormat: *const ::std::os::raw::c_char, + ... + ); +} +extern "C" { + pub fn sqlite3_wal_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_wal_autocheckpoint( + db: *mut sqlite3, + N: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_wal_checkpoint( + db: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_wal_checkpoint_v2( + db: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + eMode: ::std::os::raw::c_int, + pnLog: *mut ::std::os::raw::c_int, + pnCkpt: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_vtab_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_stmt_scanstatus( + pStmt: *mut sqlite3_stmt, + idx: ::std::os::raw::c_int, + iScanStatusOp: ::std::os::raw::c_int, + pOut: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_stmt_scanstatus_reset(arg1: *mut sqlite3_stmt); +} +extern "C" { + pub fn sqlite3_db_cacheflush(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_preupdate_hook( + db: *mut sqlite3, + xPreUpdate: ::std::option::Option< + unsafe extern "C" fn( + pCtx: *mut ::std::os::raw::c_void, + db: *mut sqlite3, + op: ::std::os::raw::c_int, + zDb: *const ::std::os::raw::c_char, + zName: *const ::std::os::raw::c_char, + iKey1: sqlite3_int64, + iKey2: sqlite3_int64, + ), + >, + arg1: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_preupdate_old( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_preupdate_count(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_preupdate_depth(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_preupdate_new( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_system_errno(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_snapshot { + _unused: [u8; 0], +} +extern "C" { + pub fn sqlite3_snapshot_get( + db: *mut sqlite3, + zSchema: *const ::std::os::raw::c_char, + ppSnapshot: *mut *mut sqlite3_snapshot, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_snapshot_open( + db: *mut sqlite3, + zSchema: *const ::std::os::raw::c_char, + pSnapshot: *mut sqlite3_snapshot, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_snapshot_free(arg1: *mut sqlite3_snapshot); +} +extern "C" { + pub fn sqlite3_snapshot_cmp( + p1: *mut sqlite3_snapshot, + p2: *mut sqlite3_snapshot, + ) -> ::std::os::raw::c_int; +} +pub type sqlite3_rtree_dbl = f64; +extern "C" { + pub fn sqlite3_rtree_geometry_callback( + db: *mut sqlite3, + zGeom: *const ::std::os::raw::c_char, + xGeom: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_rtree_geometry, + arg2: ::std::os::raw::c_int, + arg3: *mut sqlite3_rtree_dbl, + arg4: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pContext: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_geometry { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut sqlite3_rtree_dbl, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_geometry() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(xDelUser) + ) + ); +} +extern "C" { + pub fn sqlite3_rtree_query_callback( + db: *mut sqlite3, + zQueryFunc: *const ::std::os::raw::c_char, + xQueryFunc: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_rtree_query_info) -> ::std::os::raw::c_int, + >, + pContext: *mut ::std::os::raw::c_void, + xDestructor: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_query_info { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut sqlite3_rtree_dbl, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, + pub aCoord: *mut sqlite3_rtree_dbl, + pub anQueue: *mut ::std::os::raw::c_uint, + pub nCoord: ::std::os::raw::c_int, + pub iLevel: ::std::os::raw::c_int, + pub mxLevel: ::std::os::raw::c_int, + pub iRowid: sqlite3_int64, + pub rParentScore: sqlite3_rtree_dbl, + pub eParentWithin: ::std::os::raw::c_int, + pub eWithin: ::std::os::raw::c_int, + pub rScore: sqlite3_rtree_dbl, + pub apSqlParam: *mut *mut sqlite3_value, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_query_info() { + assert_eq!( + ::std::mem::size_of::(), + 112usize, + concat!("Size of: ", stringify!(sqlite3_rtree_query_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_query_info)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).pContext as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDelUser as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(xDelUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aCoord as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(aCoord) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).anQueue as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(anQueue) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nCoord as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(nCoord) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iLevel as *const _ as usize }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(iLevel) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mxLevel as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(mxLevel) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iRowid as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(iRowid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rParentScore as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(rParentScore) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eParentWithin as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(eParentWithin) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eWithin as *const _ as usize + }, + 92usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(eWithin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).rScore as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(rScore) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).apSqlParam as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(apSqlParam) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5Context { + _unused: [u8; 0], +} +pub type fts5_extension_function = ::std::option::Option< + unsafe extern "C" fn( + pApi: *const Fts5ExtensionApi, + pFts: *mut Fts5Context, + pCtx: *mut sqlite3_context, + nVal: ::std::os::raw::c_int, + apVal: *mut *mut sqlite3_value, + ), +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5PhraseIter { + pub a: *const ::std::os::raw::c_uchar, + pub b: *const ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_Fts5PhraseIter() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Fts5PhraseIter)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Fts5PhraseIter)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).a as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Fts5PhraseIter), + "::", + stringify!(a) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).b as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Fts5PhraseIter), + "::", + stringify!(b) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5ExtensionApi { + pub iVersion: ::std::os::raw::c_int, + pub xUserData: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> *mut ::std::os::raw::c_void, + >, + pub xColumnCount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, + >, + pub xRowCount: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pnRow: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xColumnTotalSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pnToken: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTokenize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pText: *const ::std::os::raw::c_char, + nText: ::std::os::raw::c_int, + pCtx: *mut ::std::os::raw::c_void, + xToken: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + arg6: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseCount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, + >, + pub xPhraseSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xInstCount: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pnInst: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xInst: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iIdx: ::std::os::raw::c_int, + piPhrase: *mut ::std::os::raw::c_int, + piCol: *mut ::std::os::raw::c_int, + piOff: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: + ::std::option::Option sqlite3_int64>, + pub xColumnText: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pz: *mut *const ::std::os::raw::c_char, + pn: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xColumnSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pnToken: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xQueryPhrase: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + pUserData: *mut ::std::os::raw::c_void, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const Fts5ExtensionApi, + arg2: *mut Fts5Context, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub xSetAuxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pAux: *mut ::std::os::raw::c_void, + xDelete: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub xGetAuxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + bClear: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xPhraseFirst: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + arg2: *mut Fts5PhraseIter, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseNext: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + arg2: *mut Fts5PhraseIter, + piCol: *mut ::std::os::raw::c_int, + piOff: *mut ::std::os::raw::c_int, + ), + >, + pub xPhraseFirstColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + arg2: *mut Fts5PhraseIter, + arg3: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseNextColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + arg2: *mut Fts5PhraseIter, + piCol: *mut ::std::os::raw::c_int, + ), + >, +} +#[test] +fn bindgen_test_layout_Fts5ExtensionApi() { + assert_eq!( + ::std::mem::size_of::(), + 160usize, + concat!("Size of: ", stringify!(Fts5ExtensionApi)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Fts5ExtensionApi)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUserData as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xUserData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnCount as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowCount as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xRowCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xColumnTotalSize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnTotalSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xTokenize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseCount as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseSize as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInstCount as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xInstCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInst as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xInst) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnText as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnText) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnSize as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xQueryPhrase as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xQueryPhrase) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetAuxdata as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xSetAuxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetAuxdata as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xGetAuxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseFirst as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseFirst) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseNext as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseNext) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPhraseFirstColumn as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseFirstColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPhraseNextColumn as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseNextColumn) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5Tokenizer { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct fts5_tokenizer { + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + azArg: *mut *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ppOut: *mut *mut Fts5Tokenizer, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option, + pub xTokenize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Tokenizer, + pCtx: *mut ::std::os::raw::c_void, + flags: ::std::os::raw::c_int, + pText: *const ::std::os::raw::c_char, + nText: ::std::os::raw::c_int, + xToken: ::std::option::Option< + unsafe extern "C" fn( + pCtx: *mut ::std::os::raw::c_void, + tflags: ::std::os::raw::c_int, + pToken: *const ::std::os::raw::c_char, + nToken: ::std::os::raw::c_int, + iStart: ::std::os::raw::c_int, + iEnd: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_fts5_tokenizer() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(fts5_tokenizer)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(fts5_tokenizer)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xTokenize) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct fts5_api { + pub iVersion: ::std::os::raw::c_int, + pub xCreateTokenizer: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + pContext: *mut ::std::os::raw::c_void, + pTokenizer: *mut fts5_tokenizer, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub xFindTokenizer: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + ppContext: *mut *mut ::std::os::raw::c_void, + pTokenizer: *mut fts5_tokenizer, + ) -> ::std::os::raw::c_int, + >, + pub xCreateFunction: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + pContext: *mut ::std::os::raw::c_void, + xFunction: fts5_extension_function, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_fts5_api() { + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(fts5_api)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(fts5_api)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreateTokenizer as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xCreateTokenizer) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindTokenizer as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xFindTokenizer) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreateFunction as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xCreateFunction) + ) + ); +} +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.20.0-ext-embed.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.20.0-ext-embed.rs new file mode 100644 index 000000000..43ed41594 --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.20.0-ext-embed.rs @@ -0,0 +1,10509 @@ +/* automatically generated by rust-bindgen */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.20.0\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3020000; +pub const SQLITE_SOURCE_ID: &'static [u8; 85usize] = + b"2017-08-01 13:24:15 9501e22dfeebdcefa783575e47c60b514d7c2e0cad73b2a496c0bc4b680900a8\0"; +pub const SQLITE_OK: i32 = 0; +pub const SQLITE_ERROR: i32 = 1; +pub const SQLITE_INTERNAL: i32 = 2; +pub const SQLITE_PERM: i32 = 3; +pub const SQLITE_ABORT: i32 = 4; +pub const SQLITE_BUSY: i32 = 5; +pub const SQLITE_LOCKED: i32 = 6; +pub const SQLITE_NOMEM: i32 = 7; +pub const SQLITE_READONLY: i32 = 8; +pub const SQLITE_INTERRUPT: i32 = 9; +pub const SQLITE_IOERR: i32 = 10; +pub const SQLITE_CORRUPT: i32 = 11; +pub const SQLITE_NOTFOUND: i32 = 12; +pub const SQLITE_FULL: i32 = 13; +pub const SQLITE_CANTOPEN: i32 = 14; +pub const SQLITE_PROTOCOL: i32 = 15; +pub const SQLITE_EMPTY: i32 = 16; +pub const SQLITE_SCHEMA: i32 = 17; +pub const SQLITE_TOOBIG: i32 = 18; +pub const SQLITE_CONSTRAINT: i32 = 19; +pub const SQLITE_MISMATCH: i32 = 20; +pub const SQLITE_MISUSE: i32 = 21; +pub const SQLITE_NOLFS: i32 = 22; +pub const SQLITE_AUTH: i32 = 23; +pub const SQLITE_FORMAT: i32 = 24; +pub const SQLITE_RANGE: i32 = 25; +pub const SQLITE_NOTADB: i32 = 26; +pub const SQLITE_NOTICE: i32 = 27; +pub const SQLITE_WARNING: i32 = 28; +pub const SQLITE_ROW: i32 = 100; +pub const SQLITE_DONE: i32 = 101; +pub const SQLITE_IOERR_READ: i32 = 266; +pub const SQLITE_IOERR_SHORT_READ: i32 = 522; +pub const SQLITE_IOERR_WRITE: i32 = 778; +pub const SQLITE_IOERR_FSYNC: i32 = 1034; +pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; +pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; +pub const SQLITE_IOERR_FSTAT: i32 = 1802; +pub const SQLITE_IOERR_UNLOCK: i32 = 2058; +pub const SQLITE_IOERR_RDLOCK: i32 = 2314; +pub const SQLITE_IOERR_DELETE: i32 = 2570; +pub const SQLITE_IOERR_BLOCKED: i32 = 2826; +pub const SQLITE_IOERR_NOMEM: i32 = 3082; +pub const SQLITE_IOERR_ACCESS: i32 = 3338; +pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; +pub const SQLITE_IOERR_LOCK: i32 = 3850; +pub const SQLITE_IOERR_CLOSE: i32 = 4106; +pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; +pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; +pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; +pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; +pub const SQLITE_IOERR_SHMMAP: i32 = 5386; +pub const SQLITE_IOERR_SEEK: i32 = 5642; +pub const SQLITE_IOERR_DELETE_NOENT: i32 = 5898; +pub const SQLITE_IOERR_MMAP: i32 = 6154; +pub const SQLITE_IOERR_GETTEMPPATH: i32 = 6410; +pub const SQLITE_IOERR_CONVPATH: i32 = 6666; +pub const SQLITE_IOERR_VNODE: i32 = 6922; +pub const SQLITE_IOERR_AUTH: i32 = 7178; +pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; +pub const SQLITE_BUSY_RECOVERY: i32 = 261; +pub const SQLITE_BUSY_SNAPSHOT: i32 = 517; +pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; +pub const SQLITE_CANTOPEN_ISDIR: i32 = 526; +pub const SQLITE_CANTOPEN_FULLPATH: i32 = 782; +pub const SQLITE_CANTOPEN_CONVPATH: i32 = 1038; +pub const SQLITE_CORRUPT_VTAB: i32 = 267; +pub const SQLITE_READONLY_RECOVERY: i32 = 264; +pub const SQLITE_READONLY_CANTLOCK: i32 = 520; +pub const SQLITE_READONLY_ROLLBACK: i32 = 776; +pub const SQLITE_READONLY_DBMOVED: i32 = 1032; +pub const SQLITE_ABORT_ROLLBACK: i32 = 516; +pub const SQLITE_CONSTRAINT_CHECK: i32 = 275; +pub const SQLITE_CONSTRAINT_COMMITHOOK: i32 = 531; +pub const SQLITE_CONSTRAINT_FOREIGNKEY: i32 = 787; +pub const SQLITE_CONSTRAINT_FUNCTION: i32 = 1043; +pub const SQLITE_CONSTRAINT_NOTNULL: i32 = 1299; +pub const SQLITE_CONSTRAINT_PRIMARYKEY: i32 = 1555; +pub const SQLITE_CONSTRAINT_TRIGGER: i32 = 1811; +pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067; +pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323; +pub const SQLITE_CONSTRAINT_ROWID: i32 = 2579; +pub const SQLITE_NOTICE_RECOVER_WAL: i32 = 283; +pub const SQLITE_NOTICE_RECOVER_ROLLBACK: i32 = 539; +pub const SQLITE_WARNING_AUTOINDEX: i32 = 284; +pub const SQLITE_AUTH_USER: i32 = 279; +pub const SQLITE_OK_LOAD_PERMANENTLY: i32 = 256; +pub const SQLITE_OPEN_READONLY: i32 = 1; +pub const SQLITE_OPEN_READWRITE: i32 = 2; +pub const SQLITE_OPEN_CREATE: i32 = 4; +pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; +pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; +pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; +pub const SQLITE_OPEN_URI: i32 = 64; +pub const SQLITE_OPEN_MEMORY: i32 = 128; +pub const SQLITE_OPEN_MAIN_DB: i32 = 256; +pub const SQLITE_OPEN_TEMP_DB: i32 = 512; +pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; +pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; +pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; +pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; +pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; +pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; +pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; +pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; +pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; +pub const SQLITE_OPEN_WAL: i32 = 524288; +pub const SQLITE_IOCAP_ATOMIC: i32 = 1; +pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; +pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; +pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; +pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; +pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; +pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; +pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; +pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; +pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; +pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; +pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; +pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE: i32 = 4096; +pub const SQLITE_IOCAP_IMMUTABLE: i32 = 8192; +pub const SQLITE_LOCK_NONE: i32 = 0; +pub const SQLITE_LOCK_SHARED: i32 = 1; +pub const SQLITE_LOCK_RESERVED: i32 = 2; +pub const SQLITE_LOCK_PENDING: i32 = 3; +pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; +pub const SQLITE_SYNC_NORMAL: i32 = 2; +pub const SQLITE_SYNC_FULL: i32 = 3; +pub const SQLITE_SYNC_DATAONLY: i32 = 16; +pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; +pub const SQLITE_FCNTL_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_FCNTL_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_FCNTL_LAST_ERRNO: i32 = 4; +pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; +pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; +pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; +pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; +pub const SQLITE_FCNTL_WIN32_AV_RETRY: i32 = 9; +pub const SQLITE_FCNTL_PERSIST_WAL: i32 = 10; +pub const SQLITE_FCNTL_OVERWRITE: i32 = 11; +pub const SQLITE_FCNTL_VFSNAME: i32 = 12; +pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE: i32 = 13; +pub const SQLITE_FCNTL_PRAGMA: i32 = 14; +pub const SQLITE_FCNTL_BUSYHANDLER: i32 = 15; +pub const SQLITE_FCNTL_TEMPFILENAME: i32 = 16; +pub const SQLITE_FCNTL_MMAP_SIZE: i32 = 18; +pub const SQLITE_FCNTL_TRACE: i32 = 19; +pub const SQLITE_FCNTL_HAS_MOVED: i32 = 20; +pub const SQLITE_FCNTL_SYNC: i32 = 21; +pub const SQLITE_FCNTL_COMMIT_PHASETWO: i32 = 22; +pub const SQLITE_FCNTL_WIN32_SET_HANDLE: i32 = 23; +pub const SQLITE_FCNTL_WAL_BLOCK: i32 = 24; +pub const SQLITE_FCNTL_ZIPVFS: i32 = 25; +pub const SQLITE_FCNTL_RBU: i32 = 26; +pub const SQLITE_FCNTL_VFS_POINTER: i32 = 27; +pub const SQLITE_FCNTL_JOURNAL_POINTER: i32 = 28; +pub const SQLITE_FCNTL_WIN32_GET_HANDLE: i32 = 29; +pub const SQLITE_FCNTL_PDB: i32 = 30; +pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_LAST_ERRNO: i32 = 4; +pub const SQLITE_ACCESS_EXISTS: i32 = 0; +pub const SQLITE_ACCESS_READWRITE: i32 = 1; +pub const SQLITE_ACCESS_READ: i32 = 2; +pub const SQLITE_SHM_UNLOCK: i32 = 1; +pub const SQLITE_SHM_LOCK: i32 = 2; +pub const SQLITE_SHM_SHARED: i32 = 4; +pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; +pub const SQLITE_SHM_NLOCK: i32 = 8; +pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; +pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; +pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; +pub const SQLITE_CONFIG_MALLOC: i32 = 4; +pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; +pub const SQLITE_CONFIG_SCRATCH: i32 = 6; +pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; +pub const SQLITE_CONFIG_HEAP: i32 = 8; +pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; +pub const SQLITE_CONFIG_MUTEX: i32 = 10; +pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; +pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; +pub const SQLITE_CONFIG_PCACHE: i32 = 14; +pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; +pub const SQLITE_CONFIG_LOG: i32 = 16; +pub const SQLITE_CONFIG_URI: i32 = 17; +pub const SQLITE_CONFIG_PCACHE2: i32 = 18; +pub const SQLITE_CONFIG_GETPCACHE2: i32 = 19; +pub const SQLITE_CONFIG_COVERING_INDEX_SCAN: i32 = 20; +pub const SQLITE_CONFIG_SQLLOG: i32 = 21; +pub const SQLITE_CONFIG_MMAP_SIZE: i32 = 22; +pub const SQLITE_CONFIG_WIN32_HEAPSIZE: i32 = 23; +pub const SQLITE_CONFIG_PCACHE_HDRSZ: i32 = 24; +pub const SQLITE_CONFIG_PMASZ: i32 = 25; +pub const SQLITE_CONFIG_STMTJRNL_SPILL: i32 = 26; +pub const SQLITE_DBCONFIG_MAINDBNAME: i32 = 1000; +pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; +pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; +pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; +pub const SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: i32 = 1004; +pub const SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: i32 = 1005; +pub const SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE: i32 = 1006; +pub const SQLITE_DBCONFIG_ENABLE_QPSG: i32 = 1007; +pub const SQLITE_DENY: i32 = 1; +pub const SQLITE_IGNORE: i32 = 2; +pub const SQLITE_CREATE_INDEX: i32 = 1; +pub const SQLITE_CREATE_TABLE: i32 = 2; +pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; +pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; +pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; +pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; +pub const SQLITE_CREATE_TRIGGER: i32 = 7; +pub const SQLITE_CREATE_VIEW: i32 = 8; +pub const SQLITE_DELETE: i32 = 9; +pub const SQLITE_DROP_INDEX: i32 = 10; +pub const SQLITE_DROP_TABLE: i32 = 11; +pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; +pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; +pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; +pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; +pub const SQLITE_DROP_TRIGGER: i32 = 16; +pub const SQLITE_DROP_VIEW: i32 = 17; +pub const SQLITE_INSERT: i32 = 18; +pub const SQLITE_PRAGMA: i32 = 19; +pub const SQLITE_READ: i32 = 20; +pub const SQLITE_SELECT: i32 = 21; +pub const SQLITE_TRANSACTION: i32 = 22; +pub const SQLITE_UPDATE: i32 = 23; +pub const SQLITE_ATTACH: i32 = 24; +pub const SQLITE_DETACH: i32 = 25; +pub const SQLITE_ALTER_TABLE: i32 = 26; +pub const SQLITE_REINDEX: i32 = 27; +pub const SQLITE_ANALYZE: i32 = 28; +pub const SQLITE_CREATE_VTABLE: i32 = 29; +pub const SQLITE_DROP_VTABLE: i32 = 30; +pub const SQLITE_FUNCTION: i32 = 31; +pub const SQLITE_SAVEPOINT: i32 = 32; +pub const SQLITE_COPY: i32 = 0; +pub const SQLITE_RECURSIVE: i32 = 33; +pub const SQLITE_TRACE_STMT: i32 = 1; +pub const SQLITE_TRACE_PROFILE: i32 = 2; +pub const SQLITE_TRACE_ROW: i32 = 4; +pub const SQLITE_TRACE_CLOSE: i32 = 8; +pub const SQLITE_LIMIT_LENGTH: i32 = 0; +pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; +pub const SQLITE_LIMIT_COLUMN: i32 = 2; +pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; +pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; +pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; +pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; +pub const SQLITE_LIMIT_ATTACHED: i32 = 7; +pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; +pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; +pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; +pub const SQLITE_LIMIT_WORKER_THREADS: i32 = 11; +pub const SQLITE_PREPARE_PERSISTENT: i32 = 1; +pub const SQLITE_INTEGER: i32 = 1; +pub const SQLITE_FLOAT: i32 = 2; +pub const SQLITE_BLOB: i32 = 4; +pub const SQLITE_NULL: i32 = 5; +pub const SQLITE_TEXT: i32 = 3; +pub const SQLITE3_TEXT: i32 = 3; +pub const SQLITE_UTF8: i32 = 1; +pub const SQLITE_UTF16LE: i32 = 2; +pub const SQLITE_UTF16BE: i32 = 3; +pub const SQLITE_UTF16: i32 = 4; +pub const SQLITE_ANY: i32 = 5; +pub const SQLITE_UTF16_ALIGNED: i32 = 8; +pub const SQLITE_DETERMINISTIC: i32 = 2048; +pub const SQLITE_INDEX_SCAN_UNIQUE: i32 = 1; +pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; +pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; +pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; +pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; +pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; +pub const SQLITE_INDEX_CONSTRAINT_LIKE: i32 = 65; +pub const SQLITE_INDEX_CONSTRAINT_GLOB: i32 = 66; +pub const SQLITE_INDEX_CONSTRAINT_REGEXP: i32 = 67; +pub const SQLITE_MUTEX_FAST: i32 = 0; +pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; +pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; +pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; +pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; +pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; +pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; +pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; +pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; +pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; +pub const SQLITE_MUTEX_STATIC_APP1: i32 = 8; +pub const SQLITE_MUTEX_STATIC_APP2: i32 = 9; +pub const SQLITE_MUTEX_STATIC_APP3: i32 = 10; +pub const SQLITE_MUTEX_STATIC_VFS1: i32 = 11; +pub const SQLITE_MUTEX_STATIC_VFS2: i32 = 12; +pub const SQLITE_MUTEX_STATIC_VFS3: i32 = 13; +pub const SQLITE_TESTCTRL_FIRST: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; +pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; +pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; +pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; +pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; +pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; +pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; +pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; +pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; +pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; +pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; +pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 17; +pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 18; +pub const SQLITE_TESTCTRL_EXPLAIN_STMT: i32 = 19; +pub const SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD: i32 = 19; +pub const SQLITE_TESTCTRL_NEVER_CORRUPT: i32 = 20; +pub const SQLITE_TESTCTRL_VDBE_COVERAGE: i32 = 21; +pub const SQLITE_TESTCTRL_BYTEORDER: i32 = 22; +pub const SQLITE_TESTCTRL_ISINIT: i32 = 23; +pub const SQLITE_TESTCTRL_SORTER_MMAP: i32 = 24; +pub const SQLITE_TESTCTRL_IMPOSTER: i32 = 25; +pub const SQLITE_TESTCTRL_LAST: i32 = 25; +pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; +pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; +pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; +pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; +pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; +pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; +pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; +pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; +pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; +pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; +pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; +pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; +pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; +pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; +pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; +pub const SQLITE_DBSTATUS_CACHE_HIT: i32 = 7; +pub const SQLITE_DBSTATUS_CACHE_MISS: i32 = 8; +pub const SQLITE_DBSTATUS_CACHE_WRITE: i32 = 9; +pub const SQLITE_DBSTATUS_DEFERRED_FKS: i32 = 10; +pub const SQLITE_DBSTATUS_CACHE_USED_SHARED: i32 = 11; +pub const SQLITE_DBSTATUS_MAX: i32 = 11; +pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; +pub const SQLITE_STMTSTATUS_SORT: i32 = 2; +pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; +pub const SQLITE_STMTSTATUS_VM_STEP: i32 = 4; +pub const SQLITE_STMTSTATUS_REPREPARE: i32 = 5; +pub const SQLITE_STMTSTATUS_RUN: i32 = 6; +pub const SQLITE_STMTSTATUS_MEMUSED: i32 = 99; +pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; +pub const SQLITE_CHECKPOINT_FULL: i32 = 1; +pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; +pub const SQLITE_CHECKPOINT_TRUNCATE: i32 = 3; +pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; +pub const SQLITE_ROLLBACK: i32 = 1; +pub const SQLITE_FAIL: i32 = 3; +pub const SQLITE_REPLACE: i32 = 5; +pub const SQLITE_SCANSTAT_NLOOP: i32 = 0; +pub const SQLITE_SCANSTAT_NVISIT: i32 = 1; +pub const SQLITE_SCANSTAT_EST: i32 = 2; +pub const SQLITE_SCANSTAT_NAME: i32 = 3; +pub const SQLITE_SCANSTAT_EXPLAIN: i32 = 4; +pub const SQLITE_SCANSTAT_SELECTID: i32 = 5; +pub const NOT_WITHIN: i32 = 0; +pub const PARTLY_WITHIN: i32 = 1; +pub const FULLY_WITHIN: i32 = 2; +pub const FTS5_TOKENIZE_QUERY: i32 = 1; +pub const FTS5_TOKENIZE_PREFIX: i32 = 2; +pub const FTS5_TOKENIZE_DOCUMENT: i32 = 4; +pub const FTS5_TOKENIZE_AUX: i32 = 8; +pub const FTS5_TOKEN_COLOCATED: i32 = 1; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; +extern "C" { + #[link_name = "\u{1}sqlite3_version"] + pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3 { + _unused: [u8; 0], +} +pub type sqlite_int64 = ::std::os::raw::c_longlong; +pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; +pub type sqlite3_int64 = sqlite_int64; +pub type sqlite3_uint64 = sqlite_uint64; +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_file { + pub pMethods: *const sqlite3_io_methods, +} +#[test] +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xShmMap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iPg: ::std::os::raw::c_int, + pgsz: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xShmLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + offset: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xShmBarrier: ::std::option::Option, + pub xShmUnmap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + deleteFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iOfst: sqlite3_int64, + iAmt: ::std::os::raw::c_int, + pp: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xUnfetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iOfst: sqlite3_int64, + p: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 152usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmMap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmBarrier) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmUnmap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnfetch as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnfetch) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +pub type sqlite3_syscall_ptr = ::std::option::Option; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vfs { + pub iVersion: ::std::os::raw::c_int, + pub szOsFile: ::std::os::raw::c_int, + pub mxPathname: ::std::os::raw::c_int, + pub pNext: *mut sqlite3_vfs, + pub zName: *const ::std::os::raw::c_char, + pub pAppData: *mut ::std::os::raw::c_void, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTimeInt64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xSetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: sqlite3_syscall_ptr, + ) -> ::std::os::raw::c_int, + >, + pub xGetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> sqlite3_syscall_ptr, + >, + pub xNextSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_vfs() { + assert_eq!( + ::std::mem::size_of::(), + 168usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTimeInt64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xNextSystemCall) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mem_methods { + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub pAppData: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_mem_methods() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_stmt { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_value { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_context { + _unused: [u8; 0], +} +pub type sqlite3_destructor_type = + ::std::option::Option; +extern "C" { + #[link_name = "\u{1}sqlite3_temp_directory"] + pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "\u{1}sqlite3_data_directory"] + pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSavepoint: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRelease: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRollbackTo: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 184usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSavepoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRelease) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollbackTo) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info { + pub nConstraint: ::std::os::raw::c_int, + pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, + pub nOrderBy: ::std::os::raw::c_int, + pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, + pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, + pub idxNum: ::std::os::raw::c_int, + pub idxStr: *mut ::std::os::raw::c_char, + pub needToFreeIdxStr: ::std::os::raw::c_int, + pub orderByConsumed: ::std::os::raw::c_int, + pub estimatedCost: f64, + pub estimatedRows: sqlite3_int64, + pub idxFlags: ::std::os::raw::c_int, + pub colUsed: sqlite3_uint64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint { + pub iColumn: ::std::os::raw::c_int, + pub op: ::std::os::raw::c_uchar, + pub usable: ::std::os::raw::c_uchar, + pub iTermOffset: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_orderby { + pub iColumn: ::std::os::raw::c_int, + pub desc: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint_usage { + pub argvIndex: ::std::os::raw::c_int, + pub omit: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); +} +#[test] +fn bindgen_test_layout_sqlite3_index_info() { + assert_eq!( + ::std::mem::size_of::(), + 96usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedRows as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedRows) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxFlags as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxFlags) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).colUsed as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(colUsed) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_blob { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex_methods { + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_mutex_methods() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_page { + pub pBuf: *mut ::std::os::raw::c_void, + pub pExtra: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_page() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pBuf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pExtra) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods2 { + pub iVersion: ::std::os::raw::c_int, + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + szExtra: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache_page, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, + pub xShrink: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods2() { + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iVersion as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDestroy as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShrink) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods { + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_backup { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct sqlite3_snapshot { + pub hidden: [::std::os::raw::c_uchar; 48usize], +} +#[test] +fn bindgen_test_layout_sqlite3_snapshot() { + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!("Size of: ", stringify!(sqlite3_snapshot)) + ); + assert_eq!( + ::std::mem::align_of::(), + 1usize, + concat!("Alignment of ", stringify!(sqlite3_snapshot)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).hidden as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_snapshot), + "::", + stringify!(hidden) + ) + ); +} +pub type sqlite3_rtree_dbl = f64; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_geometry { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut sqlite3_rtree_dbl, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_geometry() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(xDelUser) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_query_info { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut sqlite3_rtree_dbl, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, + pub aCoord: *mut sqlite3_rtree_dbl, + pub anQueue: *mut ::std::os::raw::c_uint, + pub nCoord: ::std::os::raw::c_int, + pub iLevel: ::std::os::raw::c_int, + pub mxLevel: ::std::os::raw::c_int, + pub iRowid: sqlite3_int64, + pub rParentScore: sqlite3_rtree_dbl, + pub eParentWithin: ::std::os::raw::c_int, + pub eWithin: ::std::os::raw::c_int, + pub rScore: sqlite3_rtree_dbl, + pub apSqlParam: *mut *mut sqlite3_value, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_query_info() { + assert_eq!( + ::std::mem::size_of::(), + 112usize, + concat!("Size of: ", stringify!(sqlite3_rtree_query_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_query_info)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).pContext as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDelUser as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(xDelUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aCoord as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(aCoord) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).anQueue as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(anQueue) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nCoord as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(nCoord) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iLevel as *const _ as usize }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(iLevel) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mxLevel as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(mxLevel) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iRowid as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(iRowid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rParentScore as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(rParentScore) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eParentWithin as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(eParentWithin) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eWithin as *const _ as usize + }, + 92usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(eWithin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).rScore as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(rScore) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).apSqlParam as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(apSqlParam) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5Context { + _unused: [u8; 0], +} +pub type fts5_extension_function = ::std::option::Option< + unsafe extern "C" fn( + pApi: *const Fts5ExtensionApi, + pFts: *mut Fts5Context, + pCtx: *mut sqlite3_context, + nVal: ::std::os::raw::c_int, + apVal: *mut *mut sqlite3_value, + ), +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5PhraseIter { + pub a: *const ::std::os::raw::c_uchar, + pub b: *const ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_Fts5PhraseIter() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Fts5PhraseIter)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Fts5PhraseIter)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).a as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Fts5PhraseIter), + "::", + stringify!(a) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).b as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Fts5PhraseIter), + "::", + stringify!(b) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5ExtensionApi { + pub iVersion: ::std::os::raw::c_int, + pub xUserData: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> *mut ::std::os::raw::c_void, + >, + pub xColumnCount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, + >, + pub xRowCount: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pnRow: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xColumnTotalSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pnToken: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTokenize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pText: *const ::std::os::raw::c_char, + nText: ::std::os::raw::c_int, + pCtx: *mut ::std::os::raw::c_void, + xToken: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + arg6: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseCount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, + >, + pub xPhraseSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xInstCount: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pnInst: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xInst: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iIdx: ::std::os::raw::c_int, + piPhrase: *mut ::std::os::raw::c_int, + piCol: *mut ::std::os::raw::c_int, + piOff: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: + ::std::option::Option sqlite3_int64>, + pub xColumnText: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pz: *mut *const ::std::os::raw::c_char, + pn: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xColumnSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pnToken: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xQueryPhrase: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + pUserData: *mut ::std::os::raw::c_void, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const Fts5ExtensionApi, + arg2: *mut Fts5Context, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub xSetAuxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pAux: *mut ::std::os::raw::c_void, + xDelete: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub xGetAuxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + bClear: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xPhraseFirst: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + arg2: *mut Fts5PhraseIter, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseNext: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + arg2: *mut Fts5PhraseIter, + piCol: *mut ::std::os::raw::c_int, + piOff: *mut ::std::os::raw::c_int, + ), + >, + pub xPhraseFirstColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + arg2: *mut Fts5PhraseIter, + arg3: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseNextColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + arg2: *mut Fts5PhraseIter, + piCol: *mut ::std::os::raw::c_int, + ), + >, +} +#[test] +fn bindgen_test_layout_Fts5ExtensionApi() { + assert_eq!( + ::std::mem::size_of::(), + 160usize, + concat!("Size of: ", stringify!(Fts5ExtensionApi)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Fts5ExtensionApi)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUserData as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xUserData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnCount as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowCount as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xRowCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xColumnTotalSize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnTotalSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xTokenize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseCount as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseSize as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInstCount as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xInstCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInst as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xInst) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnText as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnText) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnSize as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xQueryPhrase as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xQueryPhrase) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetAuxdata as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xSetAuxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetAuxdata as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xGetAuxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseFirst as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseFirst) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseNext as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseNext) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPhraseFirstColumn as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseFirstColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPhraseNextColumn as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseNextColumn) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5Tokenizer { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct fts5_tokenizer { + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + azArg: *mut *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ppOut: *mut *mut Fts5Tokenizer, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option, + pub xTokenize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Tokenizer, + pCtx: *mut ::std::os::raw::c_void, + flags: ::std::os::raw::c_int, + pText: *const ::std::os::raw::c_char, + nText: ::std::os::raw::c_int, + xToken: ::std::option::Option< + unsafe extern "C" fn( + pCtx: *mut ::std::os::raw::c_void, + tflags: ::std::os::raw::c_int, + pToken: *const ::std::os::raw::c_char, + nToken: ::std::os::raw::c_int, + iStart: ::std::os::raw::c_int, + iEnd: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_fts5_tokenizer() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(fts5_tokenizer)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(fts5_tokenizer)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xTokenize) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct fts5_api { + pub iVersion: ::std::os::raw::c_int, + pub xCreateTokenizer: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + pContext: *mut ::std::os::raw::c_void, + pTokenizer: *mut fts5_tokenizer, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub xFindTokenizer: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + ppContext: *mut *mut ::std::os::raw::c_void, + pTokenizer: *mut fts5_tokenizer, + ) -> ::std::os::raw::c_int, + >, + pub xCreateFunction: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + pContext: *mut ::std::os::raw::c_void, + xFunction: fts5_extension_function, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_fts5_api() { + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(fts5_api)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(fts5_api)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreateTokenizer as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xCreateTokenizer) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindTokenizer as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xFindTokenizer) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreateFunction as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xCreateFunction) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_api_routines { + pub aggregate_context: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub aggregate_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, + >, + pub bind_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_double: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int, + >, + pub bind_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, + ) -> ::std::os::raw::c_int, + >, + pub bind_null: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub bind_parameter_index: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub bind_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub busy_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub busy_timeout: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub changes: + ::std::option::Option ::std::os::raw::c_int>, + pub close: + ::std::option::Option ::std::os::raw::c_int>, + pub collation_needed: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub collation_needed16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub column_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_bytes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_bytes16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub column_database_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_database_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_decltype: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_decltype16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_double: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, + >, + pub column_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_int64: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, + >, + pub column_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_origin_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_origin_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_table_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_table_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar, + >, + pub column_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_type: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value, + >, + pub commit_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub complete: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub complete16: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub create_collation: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_collation16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_function16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_module: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub data_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub db_handle: + ::std::option::Option *mut sqlite3>, + pub declare_vtab: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub enable_shared_cache: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub errmsg: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, + >, + pub errmsg16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, + >, + pub exec: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub expired: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub finalize: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub free: ::std::option::Option, + pub free_table: + ::std::option::Option, + pub get_autocommit: + ::std::option::Option ::std::os::raw::c_int>, + pub get_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub get_table: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub global_recover: ::std::option::Option ::std::os::raw::c_int>, + pub interruptx: ::std::option::Option, + pub last_insert_rowid: + ::std::option::Option sqlite_int64>, + pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, + pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, + pub malloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub mprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub open16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub prepare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub profile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub progress_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ), + >, + pub realloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub result_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_double: + ::std::option::Option, + pub result_error: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_error16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_int64: + ::std::option::Option, + pub result_null: ::std::option::Option, + pub result_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16be: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16le: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_value: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), + >, + pub rollback_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub set_authorizer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub set_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, + ), + >, + pub snprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub step: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub table_column_metadata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub thread_cleanup: ::std::option::Option, + pub total_changes: + ::std::option::Option ::std::os::raw::c_int>, + pub trace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub transfer_bindings: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int, + >, + pub update_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub user_data: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, + >, + pub value_blob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_bytes16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_double: ::std::option::Option f64>, + pub value_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_int64: + ::std::option::Option sqlite_int64>, + pub value_numeric_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_text: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, + >, + pub value_text16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16be: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16le: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub vmprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub overload_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub prepare_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub clear_bindings: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub create_module_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_close: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int, + >, + pub blob_read: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_write: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub create_collation_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub file_control: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub memory_highwater: + ::std::option::Option sqlite3_int64>, + pub memory_used: ::std::option::Option sqlite3_int64>, + pub mutex_alloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub mutex_enter: ::std::option::Option, + pub mutex_free: ::std::option::Option, + pub mutex_leave: ::std::option::Option, + pub mutex_try: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub open_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub release_memory: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub result_error_nomem: ::std::option::Option, + pub result_error_toobig: + ::std::option::Option, + pub sleep: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub soft_heap_limit: ::std::option::Option, + pub vfs_find: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, + >, + pub vfs_register: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub vfs_unregister: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, + >, + pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, + pub result_zeroblob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_error_code: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub test_control: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, + >, + pub randomness: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), + >, + pub context_db_handle: + ::std::option::Option *mut sqlite3>, + pub extended_result_codes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub limit: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub next_stmt: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, + >, + pub sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, + >, + pub status: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub backup_finish: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_init: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, + ) -> *mut sqlite3_backup, + >, + pub backup_pagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_remaining: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_step: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub compileoption_get: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, + >, + pub compileoption_used: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub create_function_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub db_config: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int, + >, + pub db_mutex: + ::std::option::Option *mut sqlite3_mutex>, + pub db_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub extended_errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub log: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char, ...), + >, + pub soft_heap_limit64: + ::std::option::Option sqlite3_int64>, + pub sourceid: ::std::option::Option *const ::std::os::raw::c_char>, + pub stmt_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub strnicmp: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub unlock_notify: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub wal_autocheckpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub wal_checkpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub wal_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub blob_reopen: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob, arg2: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub vtab_config: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int, + >, + pub vtab_on_conflict: + ::std::option::Option ::std::os::raw::c_int>, + pub close_v2: + ::std::option::Option ::std::os::raw::c_int>, + pub db_filename: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, + pub db_readonly: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub db_release_memory: + ::std::option::Option ::std::os::raw::c_int>, + pub errstr: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, + >, + pub stmt_busy: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub stmt_readonly: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub stricmp: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub uri_boolean: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub uri_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64, + ) -> sqlite3_int64, + >, + pub uri_parameter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, + pub vsnprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub wal_checkpoint_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub auto_extension: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_blob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + arg6: ::std::os::raw::c_uchar, + ) -> ::std::os::raw::c_int, + >, + pub cancel_auto_extension: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub load_extension: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub malloc64: ::std::option::Option< + unsafe extern "C" fn(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void, + >, + pub msize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64, + >, + pub realloc64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_uint64, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset_auto_extension: ::std::option::Option, + pub result_blob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + ), + >, + pub result_text64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + arg5: ::std::os::raw::c_uchar, + ), + >, + pub strglob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub value_dup: ::std::option::Option< + unsafe extern "C" fn(arg1: *const sqlite3_value) -> *mut sqlite3_value, + >, + pub value_free: ::std::option::Option, + pub result_zeroblob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: sqlite3_uint64, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_uint64, + ) -> ::std::os::raw::c_int, + >, + pub value_subtype: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint, + >, + pub result_subtype: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint), + >, + pub status64: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut sqlite3_int64, + arg3: *mut sqlite3_int64, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub strlike: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_uint, + ) -> ::std::os::raw::c_int, + >, + pub db_cacheflush: + ::std::option::Option ::std::os::raw::c_int>, + pub system_errno: + ::std::option::Option ::std::os::raw::c_int>, + pub trace_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_uint, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_uint, + arg2: *mut ::std::os::raw::c_void, + arg3: *mut ::std::os::raw::c_void, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub expanded_sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char, + >, + pub set_last_insert_rowid: + ::std::option::Option, + pub prepare_v3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_uint, + arg5: *mut *mut sqlite3_stmt, + arg6: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16_v3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_uint, + arg5: *mut *mut sqlite3_stmt, + arg6: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub bind_pointer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: *const ::std::os::raw::c_char, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub result_pointer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *mut ::std::os::raw::c_void, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::option::Option, + ), + >, + pub value_pointer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_value, + arg2: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_api_routines() { + assert_eq!( + ::std::mem::size_of::(), + 1776usize, + concat!("Size of: ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_context as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_context) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_count as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_double as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_count as *const _ + as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_index as *const _ + as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_index) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_name as *const _ + as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text16 as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_handler as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_handler) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_timeout as *const _ as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_timeout) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed as *const _ as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_blob as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes as *const _ as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize + }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_count as *const _ as usize + }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name as *const _ + as usize + }, + 184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name16 as *const _ + as usize + }, + 192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype as *const _ as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize + }, + 208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_double as *const _ as usize + }, + 216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, + 224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_int64 as *const _ as usize + }, + 232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name as *const _ as usize + }, + 240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name16 as *const _ as usize + }, + 248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name as *const _ as usize + }, + 256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name16 as *const _ + as usize + }, + 264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name as *const _ as usize + }, + 272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name16 as *const _ + as usize + }, + 280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text as *const _ as usize + }, + 288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text16 as *const _ as usize + }, + 296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_type as *const _ as usize + }, + 304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_type) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_value as *const _ as usize + }, + 312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).commit_hook as *const _ as usize + }, + 320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(commit_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, + 328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, + 336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation as *const _ as usize + }, + 344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation16 as *const _ as usize + }, + 352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function as *const _ as usize + }, + 360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function16 as *const _ as usize + }, + 368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module as *const _ as usize + }, + 376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, + 384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(data_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, + 392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).declare_vtab as *const _ as usize + }, + 400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(declare_vtab) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).enable_shared_cache as *const _ + as usize + }, + 408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(enable_shared_cache) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, + 416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, + 424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, + 432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, + 440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(exec) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, + 448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(expired) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, + 456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(finalize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, + 464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, + 472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_autocommit as *const _ as usize + }, + 480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_autocommit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_auxdata as *const _ as usize + }, + 488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, + 496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).global_recover as *const _ as usize + }, + 504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(global_recover) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, + 512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(interruptx) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize + }, + 520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(last_insert_rowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, + 528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).libversion_number as *const _ as usize + }, + 536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion_number) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, + 544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, + 552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, + 560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, + 568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, + 576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, + 584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, + 592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(profile) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).progress_handler as *const _ as usize + }, + 600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(progress_handler) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, + 608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, + 616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob as *const _ as usize + }, + 624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_double as *const _ as usize + }, + 632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_double) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error as *const _ as usize + }, + 640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error16 as *const _ as usize + }, + 648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, + 656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_int64 as *const _ as usize + }, + 664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_null as *const _ as usize + }, + 672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text as *const _ as usize + }, + 680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16 as *const _ as usize + }, + 688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16be as *const _ as usize + }, + 696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16le as *const _ as usize + }, + 704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16le) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_value as *const _ as usize + }, + 712usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rollback_hook as *const _ as usize + }, + 720usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(rollback_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_authorizer as *const _ as usize + }, + 728usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_authorizer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_auxdata as *const _ as usize + }, + 736usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).snprintf as *const _ as usize }, + 744usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(snprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, + 752usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).table_column_metadata as *const _ + as usize + }, + 760usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(table_column_metadata) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize + }, + 768usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(thread_cleanup) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).total_changes as *const _ as usize + }, + 776usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(total_changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, + 784usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(trace) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize + }, + 792usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(transfer_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).update_hook as *const _ as usize + }, + 800usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(update_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, + 808usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(user_data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, + 816usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes as *const _ as usize + }, + 824usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize + }, + 832usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_double as *const _ as usize + }, + 840usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, + 848usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_int64 as *const _ as usize + }, + 856usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize + }, + 864usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_numeric_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, + 872usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16 as *const _ as usize + }, + 880usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16be as *const _ as usize + }, + 888usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16le as *const _ as usize + }, + 896usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16le) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, + 904usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, + 912usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vmprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).overload_function as *const _ as usize + }, + 920usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(overload_function) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, + 928usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize + }, + 936usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).clear_bindings as *const _ as usize + }, + 944usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(clear_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize + }, + 952usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize + }, + 960usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, + 968usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_bytes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, + 976usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_close) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, + 984usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, + 992usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_read) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, + 1000usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_write) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation_v2 as *const _ + as usize + }, + 1008usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).file_control as *const _ as usize + }, + 1016usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(file_control) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_highwater as *const _ as usize + }, + 1024usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_highwater) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_used as *const _ as usize + }, + 1032usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize + }, + 1040usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_alloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_enter as *const _ as usize + }, + 1048usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_enter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, + 1056usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_leave as *const _ as usize + }, + 1064usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_leave) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, + 1072usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_try) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, + 1080usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).release_memory as *const _ as usize + }, + 1088usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(release_memory) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize + }, + 1096usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_nomem) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_toobig as *const _ + as usize + }, + 1104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_toobig) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, + 1112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sleep) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize + }, + 1120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, + 1128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_find) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_register as *const _ as usize + }, + 1136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_register) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize + }, + 1144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_unregister) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize + }, + 1152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xthreadsafe) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize + }, + 1160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_code as *const _ as usize + }, + 1168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_code) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).test_control as *const _ as usize + }, + 1176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(test_control) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, + 1184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(randomness) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).context_db_handle as *const _ as usize + }, + 1192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(context_db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_result_codes as *const _ + as usize + }, + 1200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_result_codes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, + 1208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, + 1216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(next_stmt) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, + 1224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sql) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, + 1232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_finish as *const _ as usize + }, + 1240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_finish) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_init as *const _ as usize + }, + 1248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_init) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_pagecount as *const _ as usize + }, + 1256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_pagecount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_remaining as *const _ as usize + }, + 1264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_remaining) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_step as *const _ as usize + }, + 1272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_get as *const _ as usize + }, + 1280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_get) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_used as *const _ as usize + }, + 1288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function_v2 as *const _ as usize + }, + 1296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function_v2) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_config as *const _ as usize }, + 1304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_config) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_mutex as *const _ as usize }, + 1312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_mutex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_status as *const _ as usize }, + 1320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_errcode as *const _ as usize + }, + 1328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).log as *const _ as usize }, + 1336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(log) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit64 as *const _ as usize + }, + 1344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sourceid as *const _ as usize }, + 1352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sourceid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stmt_status as *const _ as usize + }, + 1360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_status) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strnicmp as *const _ as usize }, + 1368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strnicmp) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).unlock_notify as *const _ as usize + }, + 1376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(unlock_notify) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_autocheckpoint as *const _ as usize + }, + 1384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_autocheckpoint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_checkpoint as *const _ as usize + }, + 1392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_checkpoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).wal_hook as *const _ as usize }, + 1400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).blob_reopen as *const _ as usize + }, + 1408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_reopen) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_config as *const _ as usize + }, + 1416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_config) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_on_conflict as *const _ as usize + }, + 1424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_on_conflict) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close_v2 as *const _ as usize }, + 1432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_filename as *const _ as usize + }, + 1440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_filename) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_readonly as *const _ as usize + }, + 1448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_readonly) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_release_memory as *const _ as usize + }, + 1456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_release_memory) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errstr as *const _ as usize }, + 1464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errstr) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).stmt_busy as *const _ as usize }, + 1472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_busy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stmt_readonly as *const _ as usize + }, + 1480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_readonly) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).stricmp as *const _ as usize }, + 1488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stricmp) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).uri_boolean as *const _ as usize + }, + 1496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_boolean) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).uri_int64 as *const _ as usize }, + 1504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).uri_parameter as *const _ as usize + }, + 1512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_parameter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vsnprintf as *const _ as usize }, + 1520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vsnprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_checkpoint_v2 as *const _ as usize + }, + 1528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_checkpoint_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).auto_extension as *const _ as usize + }, + 1536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(auto_extension) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_blob64 as *const _ as usize + }, + 1544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text64 as *const _ as usize + }, + 1552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).cancel_auto_extension as *const _ + as usize + }, + 1560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(cancel_auto_extension) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).load_extension as *const _ as usize + }, + 1568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(load_extension) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc64 as *const _ as usize }, + 1576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).msize as *const _ as usize }, + 1584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(msize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc64 as *const _ as usize }, + 1592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).reset_auto_extension as *const _ + as usize + }, + 1600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset_auto_extension) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob64 as *const _ as usize + }, + 1608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text64 as *const _ as usize + }, + 1616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strglob as *const _ as usize }, + 1624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strglob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_dup as *const _ as usize }, + 1632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_dup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_free as *const _ as usize }, + 1640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob64 as *const _ as usize + }, + 1648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob64 as *const _ as usize + }, + 1656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_subtype as *const _ as usize + }, + 1664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_subtype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_subtype as *const _ as usize + }, + 1672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_subtype) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status64 as *const _ as usize }, + 1680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strlike as *const _ as usize }, + 1688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strlike) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_cacheflush as *const _ as usize + }, + 1696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_cacheflush) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).system_errno as *const _ as usize + }, + 1704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(system_errno) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).trace_v2 as *const _ as usize }, + 1712usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(trace_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).expanded_sql as *const _ as usize + }, + 1720usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(expanded_sql) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_last_insert_rowid as *const _ + as usize + }, + 1728usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_last_insert_rowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare_v3 as *const _ as usize }, + 1736usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare_v3) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).prepare16_v3 as *const _ as usize + }, + 1744usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16_v3) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_pointer as *const _ as usize + }, + 1752usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_pointer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_pointer as *const _ as usize + }, + 1760usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_pointer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_pointer as *const _ as usize + }, + 1768usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_pointer) + ) + ); +} +pub type sqlite3_loadext_entry = ::std::option::Option< + unsafe extern "C" fn( + db: *mut sqlite3, + pzErrMsg: *mut *mut ::std::os::raw::c_char, + pThunk: *const sqlite3_api_routines, + ) -> ::std::os::raw::c_int, +>; +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} + +// bindings were built with loadable_extension_embedded: +// define sqlite3_api as an extern since this code will be embedded +// within a loadable extension that defines and exports this itself +extern "C" { + #[no_mangle] + pub static mut sqlite3_api: *mut sqlite3_api_routines; +} + +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) + +pub unsafe fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_context.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_context", + " function" + )))(arg1, nBytes) +} + +pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_double", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_null", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_index.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_index", + " function" + )))(arg1, zName) +} + +pub unsafe fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_value", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_handler", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_timeout.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_timeout", + " function" + )))(arg1, ms) +} + +pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_blob", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype", + " function" + )))(arg1, i) +} + +pub unsafe fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_double", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int64", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_type", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_value", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).commit_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "commit_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete16", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_create_collation( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_collation16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_function( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_function16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function16", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_module( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).data_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "data_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).declare_vtab.expect(stringify!( + "sqlite3_api contains null pointer for ", + "declare_vtab", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).enable_shared_cache.expect(stringify!( + "sqlite3_api contains null pointer for ", + "enable_shared_cache", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errcode", + " function" + )))(db) +} + +pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_exec( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).exec.expect(stringify!( + "sqlite3_api contains null pointer for ", + "exec", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).expired.expect(stringify!( + "sqlite3_api contains null pointer for ", + "expired", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).finalize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "finalize", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free_table", + " function" + )))(result) +} + +pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_autocommit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_autocommit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_auxdata", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_get_table( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_table", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).global_recover.expect(stringify!( + "sqlite3_api contains null pointer for ", + "global_recover", + " function" + )))() +} + +pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).interruptx.expect(stringify!( + "sqlite3_api contains null pointer for ", + "interruptx", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).last_insert_rowid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "last_insert_rowid", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion", + " function" + )))() +} + +pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion_number.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion_number", + " function" + )))() +} + +pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mprintf( + arg1: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mprintf", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_open( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_open16( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_prepare( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_profile( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).profile.expect(stringify!( + "sqlite3_api contains null pointer for ", + "profile", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).progress_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "progress_handler", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_double", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_null", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16be", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16le", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_value", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).rollback_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "rollback_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_authorizer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_authorizer", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_auxdata", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_snprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).snprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "snprintf", + " function" + )))(arg1, arg2, arg3, vararg1) +} + +pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "step", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_table_column_metadata( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).table_column_metadata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "table_column_metadata", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) +} + +pub unsafe fn sqlite3_thread_cleanup() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).thread_cleanup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "thread_cleanup", + " function" + )))() +} + +pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).total_changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "total_changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).trace.expect(stringify!( + "sqlite3_api contains null pointer for ", + "trace", + " function" + )))(arg1, xTrace, arg2) +} + +pub unsafe fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).transfer_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "transfer_bindings", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).update_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "update_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).user_data.expect(stringify!( + "sqlite3_api contains null pointer for ", + "user_data", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_blob", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_double", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_numeric_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_numeric_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16be", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16le", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vmprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vmprintf", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).overload_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "overload_function", + " function" + )))(arg1, zFuncName, nArg) +} + +pub unsafe fn sqlite3_prepare_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).clear_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "clear_bindings", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_module_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module_v2", + " function" + )))(arg1, arg2, arg3, arg4, xDestroy) +} + +pub unsafe fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_open( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_open", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) +} + +pub unsafe fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_read.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_read", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_write.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_write", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_file_control( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).file_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "file_control", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_highwater.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_highwater", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_used", + " function" + )))() +} + +pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_alloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_alloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_enter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_enter", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_leave.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_leave", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_try.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_try", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_open_v2( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open_v2", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_nomem.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_nomem", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_toobig.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_toobig", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sleep.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sleep", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_find.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_find", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_register.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_register", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_unregister.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_unregister", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xthreadsafe.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xthreadsafe", + " function" + )))() +} + +pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_code.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_code", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_test_control( + arg1: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).test_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "test_control", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).randomness.expect(stringify!( + "sqlite3_api contains null pointer for ", + "randomness", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).context_db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "context_db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_result_codes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_result_codes", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_limit( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "limit", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).next_stmt.expect(stringify!( + "sqlite3_api contains null pointer for ", + "next_stmt", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_status( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_finish.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_finish", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_init( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, +) -> *mut sqlite3_backup { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_init.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_init", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_pagecount.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_pagecount", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_remaining.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_remaining", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_step( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_step", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_compileoption_get( + arg1: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_get.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_get", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_compileoption_used( + arg1: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_used", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_function_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal, xDestroy) +} + +pub unsafe fn sqlite3_db_config( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, + vararg2: &mut i32, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_config", + " function" + )))(arg1, arg2, vararg1, vararg2) +} + +pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_mutex.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_mutex", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_db_status( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_status", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_errcode", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_log( + arg1: ::std::os::raw::c_int, + arg2: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).log.expect(stringify!( + "sqlite3_api contains null pointer for ", + "log", + " function" + )))(arg1, arg2, vararg1) +} + +pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sourceid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sourceid", + " function" + )))() +} + +pub unsafe fn sqlite3_stmt_status( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_status", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_strnicmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strnicmp.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strnicmp", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_unlock_notify( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int), + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).unlock_notify.expect(stringify!( + "sqlite3_api contains null pointer for ", + "unlock_notify", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_wal_autocheckpoint( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_autocheckpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_checkpoint( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_checkpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_checkpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_reopen( + arg1: *mut sqlite3_blob, + arg2: sqlite3_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_reopen.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_reopen", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vtab_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_config", + " function" + )))(arg1, op, vararg1) +} + +pub unsafe fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_on_conflict.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_on_conflict", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close_v2", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_db_filename( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_filename.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_filename", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_db_readonly( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_readonly.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_readonly", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errstr.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errstr", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_busy.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_busy", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stmt_readonly(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_readonly.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_readonly", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stricmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stricmp.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stricmp", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_uri_boolean( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_boolean.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_boolean", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_uri_int64( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64, +) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_uri_parameter( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_parameter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_parameter", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vsnprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vsnprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vsnprintf", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_wal_checkpoint_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_checkpoint_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_checkpoint_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_auto_extension( + arg1: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).auto_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "auto_extension", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob64", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_text64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + arg6: ::std::os::raw::c_uchar, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text64", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_cancel_auto_extension( + arg1: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).cancel_auto_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "cancel_auto_extension", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_load_extension( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).load_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "load_extension", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_malloc64(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_msize(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).msize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "msize", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_realloc64( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_uint64, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset_auto_extension() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset_auto_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset_auto_extension", + " function" + )))() +} + +pub unsafe fn sqlite3_result_blob64( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob64", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text64( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + arg5: ::std::os::raw::c_uchar, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text64", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_strglob( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strglob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strglob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_value_dup(arg1: *const sqlite3_value) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_dup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_dup", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_free(arg1: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_zeroblob64( + arg1: *mut sqlite3_context, + arg2: sqlite3_uint64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_zeroblob64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_uint64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_value_subtype(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_subtype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_subtype", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_subtype(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_subtype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_subtype", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_status64( + arg1: ::std::os::raw::c_int, + arg2: *mut sqlite3_int64, + arg3: *mut sqlite3_int64, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status64", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_strlike( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_uint, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strlike.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strlike", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_db_cacheflush(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_cacheflush.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_cacheflush", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_system_errno(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).system_errno.expect(stringify!( + "sqlite3_api contains null pointer for ", + "system_errno", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_trace_v2( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_uint, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_uint, + arg2: *mut ::std::os::raw::c_void, + arg3: *mut ::std::os::raw::c_void, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).trace_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "trace_v2", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_expanded_sql(arg1: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).expanded_sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "expanded_sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_set_last_insert_rowid(arg1: *mut sqlite3, arg2: sqlite3_int64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_last_insert_rowid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_last_insert_rowid", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_prepare_v3( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_uint, + arg5: *mut *mut sqlite3_stmt, + arg6: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare_v3.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare_v3", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_prepare16_v3( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_uint, + arg5: *mut *mut sqlite3_stmt, + arg6: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16_v3.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16_v3", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_bind_pointer( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: *const ::std::os::raw::c_char, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_pointer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_pointer", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_result_pointer( + arg1: *mut sqlite3_context, + arg2: *mut ::std::os::raw::c_void, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_pointer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_pointer", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_value_pointer( + arg1: *mut sqlite3_value, + arg2: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_pointer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_pointer", + " function" + )))(arg1, arg2) +} diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.20.0-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.20.0-ext.rs new file mode 100644 index 000000000..1332e1e66 --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.20.0-ext.rs @@ -0,0 +1,10507 @@ +/* automatically generated by rust-bindgen */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.20.0\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3020000; +pub const SQLITE_SOURCE_ID: &'static [u8; 85usize] = + b"2017-08-01 13:24:15 9501e22dfeebdcefa783575e47c60b514d7c2e0cad73b2a496c0bc4b680900a8\0"; +pub const SQLITE_OK: i32 = 0; +pub const SQLITE_ERROR: i32 = 1; +pub const SQLITE_INTERNAL: i32 = 2; +pub const SQLITE_PERM: i32 = 3; +pub const SQLITE_ABORT: i32 = 4; +pub const SQLITE_BUSY: i32 = 5; +pub const SQLITE_LOCKED: i32 = 6; +pub const SQLITE_NOMEM: i32 = 7; +pub const SQLITE_READONLY: i32 = 8; +pub const SQLITE_INTERRUPT: i32 = 9; +pub const SQLITE_IOERR: i32 = 10; +pub const SQLITE_CORRUPT: i32 = 11; +pub const SQLITE_NOTFOUND: i32 = 12; +pub const SQLITE_FULL: i32 = 13; +pub const SQLITE_CANTOPEN: i32 = 14; +pub const SQLITE_PROTOCOL: i32 = 15; +pub const SQLITE_EMPTY: i32 = 16; +pub const SQLITE_SCHEMA: i32 = 17; +pub const SQLITE_TOOBIG: i32 = 18; +pub const SQLITE_CONSTRAINT: i32 = 19; +pub const SQLITE_MISMATCH: i32 = 20; +pub const SQLITE_MISUSE: i32 = 21; +pub const SQLITE_NOLFS: i32 = 22; +pub const SQLITE_AUTH: i32 = 23; +pub const SQLITE_FORMAT: i32 = 24; +pub const SQLITE_RANGE: i32 = 25; +pub const SQLITE_NOTADB: i32 = 26; +pub const SQLITE_NOTICE: i32 = 27; +pub const SQLITE_WARNING: i32 = 28; +pub const SQLITE_ROW: i32 = 100; +pub const SQLITE_DONE: i32 = 101; +pub const SQLITE_IOERR_READ: i32 = 266; +pub const SQLITE_IOERR_SHORT_READ: i32 = 522; +pub const SQLITE_IOERR_WRITE: i32 = 778; +pub const SQLITE_IOERR_FSYNC: i32 = 1034; +pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; +pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; +pub const SQLITE_IOERR_FSTAT: i32 = 1802; +pub const SQLITE_IOERR_UNLOCK: i32 = 2058; +pub const SQLITE_IOERR_RDLOCK: i32 = 2314; +pub const SQLITE_IOERR_DELETE: i32 = 2570; +pub const SQLITE_IOERR_BLOCKED: i32 = 2826; +pub const SQLITE_IOERR_NOMEM: i32 = 3082; +pub const SQLITE_IOERR_ACCESS: i32 = 3338; +pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; +pub const SQLITE_IOERR_LOCK: i32 = 3850; +pub const SQLITE_IOERR_CLOSE: i32 = 4106; +pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; +pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; +pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; +pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; +pub const SQLITE_IOERR_SHMMAP: i32 = 5386; +pub const SQLITE_IOERR_SEEK: i32 = 5642; +pub const SQLITE_IOERR_DELETE_NOENT: i32 = 5898; +pub const SQLITE_IOERR_MMAP: i32 = 6154; +pub const SQLITE_IOERR_GETTEMPPATH: i32 = 6410; +pub const SQLITE_IOERR_CONVPATH: i32 = 6666; +pub const SQLITE_IOERR_VNODE: i32 = 6922; +pub const SQLITE_IOERR_AUTH: i32 = 7178; +pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; +pub const SQLITE_BUSY_RECOVERY: i32 = 261; +pub const SQLITE_BUSY_SNAPSHOT: i32 = 517; +pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; +pub const SQLITE_CANTOPEN_ISDIR: i32 = 526; +pub const SQLITE_CANTOPEN_FULLPATH: i32 = 782; +pub const SQLITE_CANTOPEN_CONVPATH: i32 = 1038; +pub const SQLITE_CORRUPT_VTAB: i32 = 267; +pub const SQLITE_READONLY_RECOVERY: i32 = 264; +pub const SQLITE_READONLY_CANTLOCK: i32 = 520; +pub const SQLITE_READONLY_ROLLBACK: i32 = 776; +pub const SQLITE_READONLY_DBMOVED: i32 = 1032; +pub const SQLITE_ABORT_ROLLBACK: i32 = 516; +pub const SQLITE_CONSTRAINT_CHECK: i32 = 275; +pub const SQLITE_CONSTRAINT_COMMITHOOK: i32 = 531; +pub const SQLITE_CONSTRAINT_FOREIGNKEY: i32 = 787; +pub const SQLITE_CONSTRAINT_FUNCTION: i32 = 1043; +pub const SQLITE_CONSTRAINT_NOTNULL: i32 = 1299; +pub const SQLITE_CONSTRAINT_PRIMARYKEY: i32 = 1555; +pub const SQLITE_CONSTRAINT_TRIGGER: i32 = 1811; +pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067; +pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323; +pub const SQLITE_CONSTRAINT_ROWID: i32 = 2579; +pub const SQLITE_NOTICE_RECOVER_WAL: i32 = 283; +pub const SQLITE_NOTICE_RECOVER_ROLLBACK: i32 = 539; +pub const SQLITE_WARNING_AUTOINDEX: i32 = 284; +pub const SQLITE_AUTH_USER: i32 = 279; +pub const SQLITE_OK_LOAD_PERMANENTLY: i32 = 256; +pub const SQLITE_OPEN_READONLY: i32 = 1; +pub const SQLITE_OPEN_READWRITE: i32 = 2; +pub const SQLITE_OPEN_CREATE: i32 = 4; +pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; +pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; +pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; +pub const SQLITE_OPEN_URI: i32 = 64; +pub const SQLITE_OPEN_MEMORY: i32 = 128; +pub const SQLITE_OPEN_MAIN_DB: i32 = 256; +pub const SQLITE_OPEN_TEMP_DB: i32 = 512; +pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; +pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; +pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; +pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; +pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; +pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; +pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; +pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; +pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; +pub const SQLITE_OPEN_WAL: i32 = 524288; +pub const SQLITE_IOCAP_ATOMIC: i32 = 1; +pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; +pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; +pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; +pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; +pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; +pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; +pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; +pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; +pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; +pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; +pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; +pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE: i32 = 4096; +pub const SQLITE_IOCAP_IMMUTABLE: i32 = 8192; +pub const SQLITE_LOCK_NONE: i32 = 0; +pub const SQLITE_LOCK_SHARED: i32 = 1; +pub const SQLITE_LOCK_RESERVED: i32 = 2; +pub const SQLITE_LOCK_PENDING: i32 = 3; +pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; +pub const SQLITE_SYNC_NORMAL: i32 = 2; +pub const SQLITE_SYNC_FULL: i32 = 3; +pub const SQLITE_SYNC_DATAONLY: i32 = 16; +pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; +pub const SQLITE_FCNTL_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_FCNTL_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_FCNTL_LAST_ERRNO: i32 = 4; +pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; +pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; +pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; +pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; +pub const SQLITE_FCNTL_WIN32_AV_RETRY: i32 = 9; +pub const SQLITE_FCNTL_PERSIST_WAL: i32 = 10; +pub const SQLITE_FCNTL_OVERWRITE: i32 = 11; +pub const SQLITE_FCNTL_VFSNAME: i32 = 12; +pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE: i32 = 13; +pub const SQLITE_FCNTL_PRAGMA: i32 = 14; +pub const SQLITE_FCNTL_BUSYHANDLER: i32 = 15; +pub const SQLITE_FCNTL_TEMPFILENAME: i32 = 16; +pub const SQLITE_FCNTL_MMAP_SIZE: i32 = 18; +pub const SQLITE_FCNTL_TRACE: i32 = 19; +pub const SQLITE_FCNTL_HAS_MOVED: i32 = 20; +pub const SQLITE_FCNTL_SYNC: i32 = 21; +pub const SQLITE_FCNTL_COMMIT_PHASETWO: i32 = 22; +pub const SQLITE_FCNTL_WIN32_SET_HANDLE: i32 = 23; +pub const SQLITE_FCNTL_WAL_BLOCK: i32 = 24; +pub const SQLITE_FCNTL_ZIPVFS: i32 = 25; +pub const SQLITE_FCNTL_RBU: i32 = 26; +pub const SQLITE_FCNTL_VFS_POINTER: i32 = 27; +pub const SQLITE_FCNTL_JOURNAL_POINTER: i32 = 28; +pub const SQLITE_FCNTL_WIN32_GET_HANDLE: i32 = 29; +pub const SQLITE_FCNTL_PDB: i32 = 30; +pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_LAST_ERRNO: i32 = 4; +pub const SQLITE_ACCESS_EXISTS: i32 = 0; +pub const SQLITE_ACCESS_READWRITE: i32 = 1; +pub const SQLITE_ACCESS_READ: i32 = 2; +pub const SQLITE_SHM_UNLOCK: i32 = 1; +pub const SQLITE_SHM_LOCK: i32 = 2; +pub const SQLITE_SHM_SHARED: i32 = 4; +pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; +pub const SQLITE_SHM_NLOCK: i32 = 8; +pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; +pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; +pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; +pub const SQLITE_CONFIG_MALLOC: i32 = 4; +pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; +pub const SQLITE_CONFIG_SCRATCH: i32 = 6; +pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; +pub const SQLITE_CONFIG_HEAP: i32 = 8; +pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; +pub const SQLITE_CONFIG_MUTEX: i32 = 10; +pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; +pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; +pub const SQLITE_CONFIG_PCACHE: i32 = 14; +pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; +pub const SQLITE_CONFIG_LOG: i32 = 16; +pub const SQLITE_CONFIG_URI: i32 = 17; +pub const SQLITE_CONFIG_PCACHE2: i32 = 18; +pub const SQLITE_CONFIG_GETPCACHE2: i32 = 19; +pub const SQLITE_CONFIG_COVERING_INDEX_SCAN: i32 = 20; +pub const SQLITE_CONFIG_SQLLOG: i32 = 21; +pub const SQLITE_CONFIG_MMAP_SIZE: i32 = 22; +pub const SQLITE_CONFIG_WIN32_HEAPSIZE: i32 = 23; +pub const SQLITE_CONFIG_PCACHE_HDRSZ: i32 = 24; +pub const SQLITE_CONFIG_PMASZ: i32 = 25; +pub const SQLITE_CONFIG_STMTJRNL_SPILL: i32 = 26; +pub const SQLITE_DBCONFIG_MAINDBNAME: i32 = 1000; +pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; +pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; +pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; +pub const SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: i32 = 1004; +pub const SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: i32 = 1005; +pub const SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE: i32 = 1006; +pub const SQLITE_DBCONFIG_ENABLE_QPSG: i32 = 1007; +pub const SQLITE_DENY: i32 = 1; +pub const SQLITE_IGNORE: i32 = 2; +pub const SQLITE_CREATE_INDEX: i32 = 1; +pub const SQLITE_CREATE_TABLE: i32 = 2; +pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; +pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; +pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; +pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; +pub const SQLITE_CREATE_TRIGGER: i32 = 7; +pub const SQLITE_CREATE_VIEW: i32 = 8; +pub const SQLITE_DELETE: i32 = 9; +pub const SQLITE_DROP_INDEX: i32 = 10; +pub const SQLITE_DROP_TABLE: i32 = 11; +pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; +pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; +pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; +pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; +pub const SQLITE_DROP_TRIGGER: i32 = 16; +pub const SQLITE_DROP_VIEW: i32 = 17; +pub const SQLITE_INSERT: i32 = 18; +pub const SQLITE_PRAGMA: i32 = 19; +pub const SQLITE_READ: i32 = 20; +pub const SQLITE_SELECT: i32 = 21; +pub const SQLITE_TRANSACTION: i32 = 22; +pub const SQLITE_UPDATE: i32 = 23; +pub const SQLITE_ATTACH: i32 = 24; +pub const SQLITE_DETACH: i32 = 25; +pub const SQLITE_ALTER_TABLE: i32 = 26; +pub const SQLITE_REINDEX: i32 = 27; +pub const SQLITE_ANALYZE: i32 = 28; +pub const SQLITE_CREATE_VTABLE: i32 = 29; +pub const SQLITE_DROP_VTABLE: i32 = 30; +pub const SQLITE_FUNCTION: i32 = 31; +pub const SQLITE_SAVEPOINT: i32 = 32; +pub const SQLITE_COPY: i32 = 0; +pub const SQLITE_RECURSIVE: i32 = 33; +pub const SQLITE_TRACE_STMT: i32 = 1; +pub const SQLITE_TRACE_PROFILE: i32 = 2; +pub const SQLITE_TRACE_ROW: i32 = 4; +pub const SQLITE_TRACE_CLOSE: i32 = 8; +pub const SQLITE_LIMIT_LENGTH: i32 = 0; +pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; +pub const SQLITE_LIMIT_COLUMN: i32 = 2; +pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; +pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; +pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; +pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; +pub const SQLITE_LIMIT_ATTACHED: i32 = 7; +pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; +pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; +pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; +pub const SQLITE_LIMIT_WORKER_THREADS: i32 = 11; +pub const SQLITE_PREPARE_PERSISTENT: i32 = 1; +pub const SQLITE_INTEGER: i32 = 1; +pub const SQLITE_FLOAT: i32 = 2; +pub const SQLITE_BLOB: i32 = 4; +pub const SQLITE_NULL: i32 = 5; +pub const SQLITE_TEXT: i32 = 3; +pub const SQLITE3_TEXT: i32 = 3; +pub const SQLITE_UTF8: i32 = 1; +pub const SQLITE_UTF16LE: i32 = 2; +pub const SQLITE_UTF16BE: i32 = 3; +pub const SQLITE_UTF16: i32 = 4; +pub const SQLITE_ANY: i32 = 5; +pub const SQLITE_UTF16_ALIGNED: i32 = 8; +pub const SQLITE_DETERMINISTIC: i32 = 2048; +pub const SQLITE_INDEX_SCAN_UNIQUE: i32 = 1; +pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; +pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; +pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; +pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; +pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; +pub const SQLITE_INDEX_CONSTRAINT_LIKE: i32 = 65; +pub const SQLITE_INDEX_CONSTRAINT_GLOB: i32 = 66; +pub const SQLITE_INDEX_CONSTRAINT_REGEXP: i32 = 67; +pub const SQLITE_MUTEX_FAST: i32 = 0; +pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; +pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; +pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; +pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; +pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; +pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; +pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; +pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; +pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; +pub const SQLITE_MUTEX_STATIC_APP1: i32 = 8; +pub const SQLITE_MUTEX_STATIC_APP2: i32 = 9; +pub const SQLITE_MUTEX_STATIC_APP3: i32 = 10; +pub const SQLITE_MUTEX_STATIC_VFS1: i32 = 11; +pub const SQLITE_MUTEX_STATIC_VFS2: i32 = 12; +pub const SQLITE_MUTEX_STATIC_VFS3: i32 = 13; +pub const SQLITE_TESTCTRL_FIRST: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; +pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; +pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; +pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; +pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; +pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; +pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; +pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; +pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; +pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; +pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; +pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 17; +pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 18; +pub const SQLITE_TESTCTRL_EXPLAIN_STMT: i32 = 19; +pub const SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD: i32 = 19; +pub const SQLITE_TESTCTRL_NEVER_CORRUPT: i32 = 20; +pub const SQLITE_TESTCTRL_VDBE_COVERAGE: i32 = 21; +pub const SQLITE_TESTCTRL_BYTEORDER: i32 = 22; +pub const SQLITE_TESTCTRL_ISINIT: i32 = 23; +pub const SQLITE_TESTCTRL_SORTER_MMAP: i32 = 24; +pub const SQLITE_TESTCTRL_IMPOSTER: i32 = 25; +pub const SQLITE_TESTCTRL_LAST: i32 = 25; +pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; +pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; +pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; +pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; +pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; +pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; +pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; +pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; +pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; +pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; +pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; +pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; +pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; +pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; +pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; +pub const SQLITE_DBSTATUS_CACHE_HIT: i32 = 7; +pub const SQLITE_DBSTATUS_CACHE_MISS: i32 = 8; +pub const SQLITE_DBSTATUS_CACHE_WRITE: i32 = 9; +pub const SQLITE_DBSTATUS_DEFERRED_FKS: i32 = 10; +pub const SQLITE_DBSTATUS_CACHE_USED_SHARED: i32 = 11; +pub const SQLITE_DBSTATUS_MAX: i32 = 11; +pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; +pub const SQLITE_STMTSTATUS_SORT: i32 = 2; +pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; +pub const SQLITE_STMTSTATUS_VM_STEP: i32 = 4; +pub const SQLITE_STMTSTATUS_REPREPARE: i32 = 5; +pub const SQLITE_STMTSTATUS_RUN: i32 = 6; +pub const SQLITE_STMTSTATUS_MEMUSED: i32 = 99; +pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; +pub const SQLITE_CHECKPOINT_FULL: i32 = 1; +pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; +pub const SQLITE_CHECKPOINT_TRUNCATE: i32 = 3; +pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; +pub const SQLITE_ROLLBACK: i32 = 1; +pub const SQLITE_FAIL: i32 = 3; +pub const SQLITE_REPLACE: i32 = 5; +pub const SQLITE_SCANSTAT_NLOOP: i32 = 0; +pub const SQLITE_SCANSTAT_NVISIT: i32 = 1; +pub const SQLITE_SCANSTAT_EST: i32 = 2; +pub const SQLITE_SCANSTAT_NAME: i32 = 3; +pub const SQLITE_SCANSTAT_EXPLAIN: i32 = 4; +pub const SQLITE_SCANSTAT_SELECTID: i32 = 5; +pub const NOT_WITHIN: i32 = 0; +pub const PARTLY_WITHIN: i32 = 1; +pub const FULLY_WITHIN: i32 = 2; +pub const FTS5_TOKENIZE_QUERY: i32 = 1; +pub const FTS5_TOKENIZE_PREFIX: i32 = 2; +pub const FTS5_TOKENIZE_DOCUMENT: i32 = 4; +pub const FTS5_TOKENIZE_AUX: i32 = 8; +pub const FTS5_TOKEN_COLOCATED: i32 = 1; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; +extern "C" { + #[link_name = "\u{1}sqlite3_version"] + pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3 { + _unused: [u8; 0], +} +pub type sqlite_int64 = ::std::os::raw::c_longlong; +pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; +pub type sqlite3_int64 = sqlite_int64; +pub type sqlite3_uint64 = sqlite_uint64; +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_file { + pub pMethods: *const sqlite3_io_methods, +} +#[test] +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xShmMap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iPg: ::std::os::raw::c_int, + pgsz: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xShmLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + offset: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xShmBarrier: ::std::option::Option, + pub xShmUnmap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + deleteFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iOfst: sqlite3_int64, + iAmt: ::std::os::raw::c_int, + pp: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xUnfetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iOfst: sqlite3_int64, + p: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 152usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmMap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmBarrier) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmUnmap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnfetch as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnfetch) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +pub type sqlite3_syscall_ptr = ::std::option::Option; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vfs { + pub iVersion: ::std::os::raw::c_int, + pub szOsFile: ::std::os::raw::c_int, + pub mxPathname: ::std::os::raw::c_int, + pub pNext: *mut sqlite3_vfs, + pub zName: *const ::std::os::raw::c_char, + pub pAppData: *mut ::std::os::raw::c_void, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTimeInt64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xSetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: sqlite3_syscall_ptr, + ) -> ::std::os::raw::c_int, + >, + pub xGetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> sqlite3_syscall_ptr, + >, + pub xNextSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_vfs() { + assert_eq!( + ::std::mem::size_of::(), + 168usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTimeInt64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xNextSystemCall) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mem_methods { + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub pAppData: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_mem_methods() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_stmt { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_value { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_context { + _unused: [u8; 0], +} +pub type sqlite3_destructor_type = + ::std::option::Option; +extern "C" { + #[link_name = "\u{1}sqlite3_temp_directory"] + pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "\u{1}sqlite3_data_directory"] + pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSavepoint: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRelease: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRollbackTo: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 184usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSavepoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRelease) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollbackTo) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info { + pub nConstraint: ::std::os::raw::c_int, + pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, + pub nOrderBy: ::std::os::raw::c_int, + pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, + pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, + pub idxNum: ::std::os::raw::c_int, + pub idxStr: *mut ::std::os::raw::c_char, + pub needToFreeIdxStr: ::std::os::raw::c_int, + pub orderByConsumed: ::std::os::raw::c_int, + pub estimatedCost: f64, + pub estimatedRows: sqlite3_int64, + pub idxFlags: ::std::os::raw::c_int, + pub colUsed: sqlite3_uint64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint { + pub iColumn: ::std::os::raw::c_int, + pub op: ::std::os::raw::c_uchar, + pub usable: ::std::os::raw::c_uchar, + pub iTermOffset: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_orderby { + pub iColumn: ::std::os::raw::c_int, + pub desc: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint_usage { + pub argvIndex: ::std::os::raw::c_int, + pub omit: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); +} +#[test] +fn bindgen_test_layout_sqlite3_index_info() { + assert_eq!( + ::std::mem::size_of::(), + 96usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedRows as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedRows) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxFlags as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxFlags) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).colUsed as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(colUsed) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_blob { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex_methods { + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_mutex_methods() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_page { + pub pBuf: *mut ::std::os::raw::c_void, + pub pExtra: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_page() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pBuf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pExtra) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods2 { + pub iVersion: ::std::os::raw::c_int, + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + szExtra: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache_page, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, + pub xShrink: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods2() { + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iVersion as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDestroy as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShrink) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods { + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_backup { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct sqlite3_snapshot { + pub hidden: [::std::os::raw::c_uchar; 48usize], +} +#[test] +fn bindgen_test_layout_sqlite3_snapshot() { + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!("Size of: ", stringify!(sqlite3_snapshot)) + ); + assert_eq!( + ::std::mem::align_of::(), + 1usize, + concat!("Alignment of ", stringify!(sqlite3_snapshot)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).hidden as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_snapshot), + "::", + stringify!(hidden) + ) + ); +} +pub type sqlite3_rtree_dbl = f64; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_geometry { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut sqlite3_rtree_dbl, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_geometry() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(xDelUser) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_query_info { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut sqlite3_rtree_dbl, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, + pub aCoord: *mut sqlite3_rtree_dbl, + pub anQueue: *mut ::std::os::raw::c_uint, + pub nCoord: ::std::os::raw::c_int, + pub iLevel: ::std::os::raw::c_int, + pub mxLevel: ::std::os::raw::c_int, + pub iRowid: sqlite3_int64, + pub rParentScore: sqlite3_rtree_dbl, + pub eParentWithin: ::std::os::raw::c_int, + pub eWithin: ::std::os::raw::c_int, + pub rScore: sqlite3_rtree_dbl, + pub apSqlParam: *mut *mut sqlite3_value, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_query_info() { + assert_eq!( + ::std::mem::size_of::(), + 112usize, + concat!("Size of: ", stringify!(sqlite3_rtree_query_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_query_info)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).pContext as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDelUser as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(xDelUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aCoord as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(aCoord) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).anQueue as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(anQueue) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nCoord as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(nCoord) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iLevel as *const _ as usize }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(iLevel) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mxLevel as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(mxLevel) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iRowid as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(iRowid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rParentScore as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(rParentScore) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eParentWithin as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(eParentWithin) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eWithin as *const _ as usize + }, + 92usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(eWithin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).rScore as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(rScore) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).apSqlParam as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(apSqlParam) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5Context { + _unused: [u8; 0], +} +pub type fts5_extension_function = ::std::option::Option< + unsafe extern "C" fn( + pApi: *const Fts5ExtensionApi, + pFts: *mut Fts5Context, + pCtx: *mut sqlite3_context, + nVal: ::std::os::raw::c_int, + apVal: *mut *mut sqlite3_value, + ), +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5PhraseIter { + pub a: *const ::std::os::raw::c_uchar, + pub b: *const ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_Fts5PhraseIter() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Fts5PhraseIter)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Fts5PhraseIter)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).a as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Fts5PhraseIter), + "::", + stringify!(a) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).b as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Fts5PhraseIter), + "::", + stringify!(b) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5ExtensionApi { + pub iVersion: ::std::os::raw::c_int, + pub xUserData: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> *mut ::std::os::raw::c_void, + >, + pub xColumnCount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, + >, + pub xRowCount: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pnRow: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xColumnTotalSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pnToken: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTokenize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pText: *const ::std::os::raw::c_char, + nText: ::std::os::raw::c_int, + pCtx: *mut ::std::os::raw::c_void, + xToken: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + arg6: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseCount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, + >, + pub xPhraseSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xInstCount: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pnInst: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xInst: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iIdx: ::std::os::raw::c_int, + piPhrase: *mut ::std::os::raw::c_int, + piCol: *mut ::std::os::raw::c_int, + piOff: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: + ::std::option::Option sqlite3_int64>, + pub xColumnText: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pz: *mut *const ::std::os::raw::c_char, + pn: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xColumnSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pnToken: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xQueryPhrase: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + pUserData: *mut ::std::os::raw::c_void, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const Fts5ExtensionApi, + arg2: *mut Fts5Context, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub xSetAuxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pAux: *mut ::std::os::raw::c_void, + xDelete: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub xGetAuxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + bClear: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xPhraseFirst: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + arg2: *mut Fts5PhraseIter, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseNext: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + arg2: *mut Fts5PhraseIter, + piCol: *mut ::std::os::raw::c_int, + piOff: *mut ::std::os::raw::c_int, + ), + >, + pub xPhraseFirstColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + arg2: *mut Fts5PhraseIter, + arg3: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseNextColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + arg2: *mut Fts5PhraseIter, + piCol: *mut ::std::os::raw::c_int, + ), + >, +} +#[test] +fn bindgen_test_layout_Fts5ExtensionApi() { + assert_eq!( + ::std::mem::size_of::(), + 160usize, + concat!("Size of: ", stringify!(Fts5ExtensionApi)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Fts5ExtensionApi)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUserData as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xUserData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnCount as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowCount as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xRowCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xColumnTotalSize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnTotalSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xTokenize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseCount as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseSize as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInstCount as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xInstCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInst as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xInst) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnText as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnText) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnSize as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xQueryPhrase as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xQueryPhrase) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetAuxdata as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xSetAuxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetAuxdata as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xGetAuxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseFirst as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseFirst) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseNext as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseNext) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPhraseFirstColumn as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseFirstColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPhraseNextColumn as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseNextColumn) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5Tokenizer { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct fts5_tokenizer { + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + azArg: *mut *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ppOut: *mut *mut Fts5Tokenizer, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option, + pub xTokenize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Tokenizer, + pCtx: *mut ::std::os::raw::c_void, + flags: ::std::os::raw::c_int, + pText: *const ::std::os::raw::c_char, + nText: ::std::os::raw::c_int, + xToken: ::std::option::Option< + unsafe extern "C" fn( + pCtx: *mut ::std::os::raw::c_void, + tflags: ::std::os::raw::c_int, + pToken: *const ::std::os::raw::c_char, + nToken: ::std::os::raw::c_int, + iStart: ::std::os::raw::c_int, + iEnd: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_fts5_tokenizer() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(fts5_tokenizer)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(fts5_tokenizer)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xTokenize) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct fts5_api { + pub iVersion: ::std::os::raw::c_int, + pub xCreateTokenizer: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + pContext: *mut ::std::os::raw::c_void, + pTokenizer: *mut fts5_tokenizer, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub xFindTokenizer: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + ppContext: *mut *mut ::std::os::raw::c_void, + pTokenizer: *mut fts5_tokenizer, + ) -> ::std::os::raw::c_int, + >, + pub xCreateFunction: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + pContext: *mut ::std::os::raw::c_void, + xFunction: fts5_extension_function, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_fts5_api() { + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(fts5_api)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(fts5_api)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreateTokenizer as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xCreateTokenizer) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindTokenizer as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xFindTokenizer) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreateFunction as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xCreateFunction) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_api_routines { + pub aggregate_context: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub aggregate_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, + >, + pub bind_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_double: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int, + >, + pub bind_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, + ) -> ::std::os::raw::c_int, + >, + pub bind_null: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub bind_parameter_index: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub bind_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub busy_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub busy_timeout: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub changes: + ::std::option::Option ::std::os::raw::c_int>, + pub close: + ::std::option::Option ::std::os::raw::c_int>, + pub collation_needed: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub collation_needed16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub column_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_bytes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_bytes16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub column_database_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_database_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_decltype: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_decltype16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_double: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, + >, + pub column_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_int64: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, + >, + pub column_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_origin_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_origin_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_table_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_table_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar, + >, + pub column_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_type: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value, + >, + pub commit_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub complete: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub complete16: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub create_collation: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_collation16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_function16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_module: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub data_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub db_handle: + ::std::option::Option *mut sqlite3>, + pub declare_vtab: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub enable_shared_cache: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub errmsg: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, + >, + pub errmsg16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, + >, + pub exec: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub expired: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub finalize: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub free: ::std::option::Option, + pub free_table: + ::std::option::Option, + pub get_autocommit: + ::std::option::Option ::std::os::raw::c_int>, + pub get_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub get_table: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub global_recover: ::std::option::Option ::std::os::raw::c_int>, + pub interruptx: ::std::option::Option, + pub last_insert_rowid: + ::std::option::Option sqlite_int64>, + pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, + pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, + pub malloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub mprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub open16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub prepare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub profile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub progress_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ), + >, + pub realloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub result_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_double: + ::std::option::Option, + pub result_error: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_error16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_int64: + ::std::option::Option, + pub result_null: ::std::option::Option, + pub result_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16be: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16le: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_value: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), + >, + pub rollback_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub set_authorizer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub set_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, + ), + >, + pub snprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub step: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub table_column_metadata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub thread_cleanup: ::std::option::Option, + pub total_changes: + ::std::option::Option ::std::os::raw::c_int>, + pub trace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub transfer_bindings: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int, + >, + pub update_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub user_data: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, + >, + pub value_blob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_bytes16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_double: ::std::option::Option f64>, + pub value_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_int64: + ::std::option::Option sqlite_int64>, + pub value_numeric_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_text: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, + >, + pub value_text16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16be: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16le: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub vmprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub overload_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub prepare_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub clear_bindings: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub create_module_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_close: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int, + >, + pub blob_read: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_write: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub create_collation_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub file_control: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub memory_highwater: + ::std::option::Option sqlite3_int64>, + pub memory_used: ::std::option::Option sqlite3_int64>, + pub mutex_alloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub mutex_enter: ::std::option::Option, + pub mutex_free: ::std::option::Option, + pub mutex_leave: ::std::option::Option, + pub mutex_try: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub open_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub release_memory: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub result_error_nomem: ::std::option::Option, + pub result_error_toobig: + ::std::option::Option, + pub sleep: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub soft_heap_limit: ::std::option::Option, + pub vfs_find: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, + >, + pub vfs_register: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub vfs_unregister: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, + >, + pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, + pub result_zeroblob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_error_code: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub test_control: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, + >, + pub randomness: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), + >, + pub context_db_handle: + ::std::option::Option *mut sqlite3>, + pub extended_result_codes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub limit: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub next_stmt: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, + >, + pub sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, + >, + pub status: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub backup_finish: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_init: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, + ) -> *mut sqlite3_backup, + >, + pub backup_pagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_remaining: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_step: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub compileoption_get: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, + >, + pub compileoption_used: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub create_function_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub db_config: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int, + >, + pub db_mutex: + ::std::option::Option *mut sqlite3_mutex>, + pub db_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub extended_errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub log: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char, ...), + >, + pub soft_heap_limit64: + ::std::option::Option sqlite3_int64>, + pub sourceid: ::std::option::Option *const ::std::os::raw::c_char>, + pub stmt_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub strnicmp: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub unlock_notify: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub wal_autocheckpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub wal_checkpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub wal_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub blob_reopen: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob, arg2: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub vtab_config: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int, + >, + pub vtab_on_conflict: + ::std::option::Option ::std::os::raw::c_int>, + pub close_v2: + ::std::option::Option ::std::os::raw::c_int>, + pub db_filename: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, + pub db_readonly: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub db_release_memory: + ::std::option::Option ::std::os::raw::c_int>, + pub errstr: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, + >, + pub stmt_busy: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub stmt_readonly: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub stricmp: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub uri_boolean: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub uri_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64, + ) -> sqlite3_int64, + >, + pub uri_parameter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, + pub vsnprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub wal_checkpoint_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub auto_extension: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_blob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + arg6: ::std::os::raw::c_uchar, + ) -> ::std::os::raw::c_int, + >, + pub cancel_auto_extension: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub load_extension: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub malloc64: ::std::option::Option< + unsafe extern "C" fn(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void, + >, + pub msize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64, + >, + pub realloc64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_uint64, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset_auto_extension: ::std::option::Option, + pub result_blob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + ), + >, + pub result_text64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + arg5: ::std::os::raw::c_uchar, + ), + >, + pub strglob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub value_dup: ::std::option::Option< + unsafe extern "C" fn(arg1: *const sqlite3_value) -> *mut sqlite3_value, + >, + pub value_free: ::std::option::Option, + pub result_zeroblob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: sqlite3_uint64, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_uint64, + ) -> ::std::os::raw::c_int, + >, + pub value_subtype: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint, + >, + pub result_subtype: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint), + >, + pub status64: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut sqlite3_int64, + arg3: *mut sqlite3_int64, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub strlike: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_uint, + ) -> ::std::os::raw::c_int, + >, + pub db_cacheflush: + ::std::option::Option ::std::os::raw::c_int>, + pub system_errno: + ::std::option::Option ::std::os::raw::c_int>, + pub trace_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_uint, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_uint, + arg2: *mut ::std::os::raw::c_void, + arg3: *mut ::std::os::raw::c_void, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub expanded_sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char, + >, + pub set_last_insert_rowid: + ::std::option::Option, + pub prepare_v3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_uint, + arg5: *mut *mut sqlite3_stmt, + arg6: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16_v3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_uint, + arg5: *mut *mut sqlite3_stmt, + arg6: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub bind_pointer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: *const ::std::os::raw::c_char, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub result_pointer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *mut ::std::os::raw::c_void, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::option::Option, + ), + >, + pub value_pointer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_value, + arg2: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_api_routines() { + assert_eq!( + ::std::mem::size_of::(), + 1776usize, + concat!("Size of: ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_context as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_context) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_count as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_double as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_count as *const _ + as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_index as *const _ + as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_index) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_name as *const _ + as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text16 as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_handler as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_handler) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_timeout as *const _ as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_timeout) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed as *const _ as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_blob as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes as *const _ as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize + }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_count as *const _ as usize + }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name as *const _ + as usize + }, + 184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name16 as *const _ + as usize + }, + 192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype as *const _ as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize + }, + 208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_double as *const _ as usize + }, + 216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, + 224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_int64 as *const _ as usize + }, + 232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name as *const _ as usize + }, + 240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name16 as *const _ as usize + }, + 248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name as *const _ as usize + }, + 256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name16 as *const _ + as usize + }, + 264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name as *const _ as usize + }, + 272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name16 as *const _ + as usize + }, + 280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text as *const _ as usize + }, + 288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text16 as *const _ as usize + }, + 296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_type as *const _ as usize + }, + 304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_type) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_value as *const _ as usize + }, + 312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).commit_hook as *const _ as usize + }, + 320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(commit_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, + 328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, + 336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation as *const _ as usize + }, + 344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation16 as *const _ as usize + }, + 352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function as *const _ as usize + }, + 360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function16 as *const _ as usize + }, + 368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module as *const _ as usize + }, + 376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, + 384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(data_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, + 392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).declare_vtab as *const _ as usize + }, + 400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(declare_vtab) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).enable_shared_cache as *const _ + as usize + }, + 408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(enable_shared_cache) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, + 416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, + 424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, + 432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, + 440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(exec) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, + 448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(expired) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, + 456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(finalize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, + 464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, + 472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_autocommit as *const _ as usize + }, + 480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_autocommit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_auxdata as *const _ as usize + }, + 488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, + 496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).global_recover as *const _ as usize + }, + 504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(global_recover) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, + 512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(interruptx) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize + }, + 520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(last_insert_rowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, + 528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).libversion_number as *const _ as usize + }, + 536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion_number) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, + 544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, + 552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, + 560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, + 568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, + 576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, + 584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, + 592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(profile) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).progress_handler as *const _ as usize + }, + 600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(progress_handler) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, + 608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, + 616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob as *const _ as usize + }, + 624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_double as *const _ as usize + }, + 632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_double) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error as *const _ as usize + }, + 640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error16 as *const _ as usize + }, + 648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, + 656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_int64 as *const _ as usize + }, + 664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_null as *const _ as usize + }, + 672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text as *const _ as usize + }, + 680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16 as *const _ as usize + }, + 688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16be as *const _ as usize + }, + 696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16le as *const _ as usize + }, + 704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16le) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_value as *const _ as usize + }, + 712usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rollback_hook as *const _ as usize + }, + 720usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(rollback_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_authorizer as *const _ as usize + }, + 728usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_authorizer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_auxdata as *const _ as usize + }, + 736usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).snprintf as *const _ as usize }, + 744usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(snprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, + 752usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).table_column_metadata as *const _ + as usize + }, + 760usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(table_column_metadata) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize + }, + 768usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(thread_cleanup) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).total_changes as *const _ as usize + }, + 776usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(total_changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, + 784usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(trace) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize + }, + 792usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(transfer_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).update_hook as *const _ as usize + }, + 800usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(update_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, + 808usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(user_data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, + 816usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes as *const _ as usize + }, + 824usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize + }, + 832usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_double as *const _ as usize + }, + 840usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, + 848usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_int64 as *const _ as usize + }, + 856usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize + }, + 864usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_numeric_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, + 872usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16 as *const _ as usize + }, + 880usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16be as *const _ as usize + }, + 888usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16le as *const _ as usize + }, + 896usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16le) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, + 904usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, + 912usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vmprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).overload_function as *const _ as usize + }, + 920usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(overload_function) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, + 928usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize + }, + 936usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).clear_bindings as *const _ as usize + }, + 944usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(clear_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize + }, + 952usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize + }, + 960usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, + 968usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_bytes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, + 976usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_close) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, + 984usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, + 992usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_read) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, + 1000usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_write) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation_v2 as *const _ + as usize + }, + 1008usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).file_control as *const _ as usize + }, + 1016usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(file_control) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_highwater as *const _ as usize + }, + 1024usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_highwater) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_used as *const _ as usize + }, + 1032usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize + }, + 1040usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_alloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_enter as *const _ as usize + }, + 1048usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_enter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, + 1056usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_leave as *const _ as usize + }, + 1064usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_leave) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, + 1072usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_try) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, + 1080usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).release_memory as *const _ as usize + }, + 1088usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(release_memory) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize + }, + 1096usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_nomem) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_toobig as *const _ + as usize + }, + 1104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_toobig) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, + 1112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sleep) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize + }, + 1120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, + 1128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_find) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_register as *const _ as usize + }, + 1136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_register) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize + }, + 1144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_unregister) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize + }, + 1152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xthreadsafe) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize + }, + 1160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_code as *const _ as usize + }, + 1168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_code) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).test_control as *const _ as usize + }, + 1176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(test_control) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, + 1184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(randomness) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).context_db_handle as *const _ as usize + }, + 1192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(context_db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_result_codes as *const _ + as usize + }, + 1200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_result_codes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, + 1208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, + 1216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(next_stmt) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, + 1224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sql) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, + 1232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_finish as *const _ as usize + }, + 1240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_finish) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_init as *const _ as usize + }, + 1248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_init) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_pagecount as *const _ as usize + }, + 1256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_pagecount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_remaining as *const _ as usize + }, + 1264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_remaining) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_step as *const _ as usize + }, + 1272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_get as *const _ as usize + }, + 1280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_get) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_used as *const _ as usize + }, + 1288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function_v2 as *const _ as usize + }, + 1296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function_v2) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_config as *const _ as usize }, + 1304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_config) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_mutex as *const _ as usize }, + 1312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_mutex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_status as *const _ as usize }, + 1320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_errcode as *const _ as usize + }, + 1328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).log as *const _ as usize }, + 1336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(log) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit64 as *const _ as usize + }, + 1344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sourceid as *const _ as usize }, + 1352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sourceid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stmt_status as *const _ as usize + }, + 1360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_status) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strnicmp as *const _ as usize }, + 1368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strnicmp) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).unlock_notify as *const _ as usize + }, + 1376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(unlock_notify) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_autocheckpoint as *const _ as usize + }, + 1384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_autocheckpoint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_checkpoint as *const _ as usize + }, + 1392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_checkpoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).wal_hook as *const _ as usize }, + 1400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).blob_reopen as *const _ as usize + }, + 1408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_reopen) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_config as *const _ as usize + }, + 1416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_config) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_on_conflict as *const _ as usize + }, + 1424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_on_conflict) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close_v2 as *const _ as usize }, + 1432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_filename as *const _ as usize + }, + 1440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_filename) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_readonly as *const _ as usize + }, + 1448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_readonly) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_release_memory as *const _ as usize + }, + 1456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_release_memory) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errstr as *const _ as usize }, + 1464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errstr) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).stmt_busy as *const _ as usize }, + 1472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_busy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stmt_readonly as *const _ as usize + }, + 1480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_readonly) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).stricmp as *const _ as usize }, + 1488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stricmp) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).uri_boolean as *const _ as usize + }, + 1496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_boolean) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).uri_int64 as *const _ as usize }, + 1504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).uri_parameter as *const _ as usize + }, + 1512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_parameter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vsnprintf as *const _ as usize }, + 1520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vsnprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_checkpoint_v2 as *const _ as usize + }, + 1528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_checkpoint_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).auto_extension as *const _ as usize + }, + 1536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(auto_extension) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_blob64 as *const _ as usize + }, + 1544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text64 as *const _ as usize + }, + 1552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).cancel_auto_extension as *const _ + as usize + }, + 1560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(cancel_auto_extension) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).load_extension as *const _ as usize + }, + 1568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(load_extension) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc64 as *const _ as usize }, + 1576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).msize as *const _ as usize }, + 1584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(msize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc64 as *const _ as usize }, + 1592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).reset_auto_extension as *const _ + as usize + }, + 1600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset_auto_extension) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob64 as *const _ as usize + }, + 1608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text64 as *const _ as usize + }, + 1616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strglob as *const _ as usize }, + 1624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strglob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_dup as *const _ as usize }, + 1632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_dup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_free as *const _ as usize }, + 1640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob64 as *const _ as usize + }, + 1648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob64 as *const _ as usize + }, + 1656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_subtype as *const _ as usize + }, + 1664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_subtype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_subtype as *const _ as usize + }, + 1672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_subtype) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status64 as *const _ as usize }, + 1680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strlike as *const _ as usize }, + 1688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strlike) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_cacheflush as *const _ as usize + }, + 1696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_cacheflush) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).system_errno as *const _ as usize + }, + 1704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(system_errno) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).trace_v2 as *const _ as usize }, + 1712usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(trace_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).expanded_sql as *const _ as usize + }, + 1720usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(expanded_sql) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_last_insert_rowid as *const _ + as usize + }, + 1728usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_last_insert_rowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare_v3 as *const _ as usize }, + 1736usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare_v3) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).prepare16_v3 as *const _ as usize + }, + 1744usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16_v3) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_pointer as *const _ as usize + }, + 1752usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_pointer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_pointer as *const _ as usize + }, + 1760usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_pointer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_pointer as *const _ as usize + }, + 1768usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_pointer) + ) + ); +} +pub type sqlite3_loadext_entry = ::std::option::Option< + unsafe extern "C" fn( + db: *mut sqlite3, + pzErrMsg: *mut *mut ::std::os::raw::c_char, + pThunk: *const sqlite3_api_routines, + ) -> ::std::os::raw::c_int, +>; +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} + +// bindings were built with (non-embedded) loadable_extension: +// we define our own sqlite_api static variable and export it +// to C +#[no_mangle] +pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_routines; + +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) + +pub unsafe fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_context.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_context", + " function" + )))(arg1, nBytes) +} + +pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_double", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_null", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_index.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_index", + " function" + )))(arg1, zName) +} + +pub unsafe fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_value", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_handler", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_timeout.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_timeout", + " function" + )))(arg1, ms) +} + +pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_blob", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype", + " function" + )))(arg1, i) +} + +pub unsafe fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_double", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int64", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_type", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_value", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).commit_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "commit_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete16", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_create_collation( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_collation16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_function( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_function16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function16", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_module( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).data_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "data_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).declare_vtab.expect(stringify!( + "sqlite3_api contains null pointer for ", + "declare_vtab", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).enable_shared_cache.expect(stringify!( + "sqlite3_api contains null pointer for ", + "enable_shared_cache", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errcode", + " function" + )))(db) +} + +pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_exec( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).exec.expect(stringify!( + "sqlite3_api contains null pointer for ", + "exec", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).expired.expect(stringify!( + "sqlite3_api contains null pointer for ", + "expired", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).finalize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "finalize", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free_table", + " function" + )))(result) +} + +pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_autocommit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_autocommit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_auxdata", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_get_table( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_table", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).global_recover.expect(stringify!( + "sqlite3_api contains null pointer for ", + "global_recover", + " function" + )))() +} + +pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).interruptx.expect(stringify!( + "sqlite3_api contains null pointer for ", + "interruptx", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).last_insert_rowid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "last_insert_rowid", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion", + " function" + )))() +} + +pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion_number.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion_number", + " function" + )))() +} + +pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mprintf( + arg1: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mprintf", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_open( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_open16( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_prepare( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_profile( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).profile.expect(stringify!( + "sqlite3_api contains null pointer for ", + "profile", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).progress_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "progress_handler", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_double", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_null", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16be", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16le", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_value", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).rollback_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "rollback_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_authorizer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_authorizer", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_auxdata", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_snprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).snprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "snprintf", + " function" + )))(arg1, arg2, arg3, vararg1) +} + +pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "step", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_table_column_metadata( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).table_column_metadata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "table_column_metadata", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) +} + +pub unsafe fn sqlite3_thread_cleanup() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).thread_cleanup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "thread_cleanup", + " function" + )))() +} + +pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).total_changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "total_changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).trace.expect(stringify!( + "sqlite3_api contains null pointer for ", + "trace", + " function" + )))(arg1, xTrace, arg2) +} + +pub unsafe fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).transfer_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "transfer_bindings", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).update_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "update_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).user_data.expect(stringify!( + "sqlite3_api contains null pointer for ", + "user_data", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_blob", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_double", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_numeric_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_numeric_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16be", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16le", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vmprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vmprintf", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).overload_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "overload_function", + " function" + )))(arg1, zFuncName, nArg) +} + +pub unsafe fn sqlite3_prepare_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).clear_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "clear_bindings", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_module_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module_v2", + " function" + )))(arg1, arg2, arg3, arg4, xDestroy) +} + +pub unsafe fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_open( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_open", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) +} + +pub unsafe fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_read.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_read", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_write.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_write", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_file_control( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).file_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "file_control", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_highwater.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_highwater", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_used", + " function" + )))() +} + +pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_alloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_alloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_enter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_enter", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_leave.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_leave", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_try.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_try", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_open_v2( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open_v2", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_nomem.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_nomem", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_toobig.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_toobig", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sleep.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sleep", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_find.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_find", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_register.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_register", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_unregister.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_unregister", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xthreadsafe.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xthreadsafe", + " function" + )))() +} + +pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_code.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_code", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_test_control( + arg1: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).test_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "test_control", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).randomness.expect(stringify!( + "sqlite3_api contains null pointer for ", + "randomness", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).context_db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "context_db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_result_codes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_result_codes", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_limit( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "limit", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).next_stmt.expect(stringify!( + "sqlite3_api contains null pointer for ", + "next_stmt", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_status( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_finish.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_finish", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_init( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, +) -> *mut sqlite3_backup { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_init.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_init", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_pagecount.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_pagecount", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_remaining.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_remaining", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_step( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_step", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_compileoption_get( + arg1: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_get.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_get", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_compileoption_used( + arg1: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_used", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_function_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal, xDestroy) +} + +pub unsafe fn sqlite3_db_config( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, + vararg2: &mut i32, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_config", + " function" + )))(arg1, arg2, vararg1, vararg2) +} + +pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_mutex.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_mutex", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_db_status( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_status", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_errcode", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_log( + arg1: ::std::os::raw::c_int, + arg2: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).log.expect(stringify!( + "sqlite3_api contains null pointer for ", + "log", + " function" + )))(arg1, arg2, vararg1) +} + +pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sourceid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sourceid", + " function" + )))() +} + +pub unsafe fn sqlite3_stmt_status( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_status", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_strnicmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strnicmp.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strnicmp", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_unlock_notify( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int), + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).unlock_notify.expect(stringify!( + "sqlite3_api contains null pointer for ", + "unlock_notify", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_wal_autocheckpoint( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_autocheckpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_checkpoint( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_checkpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_checkpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_reopen( + arg1: *mut sqlite3_blob, + arg2: sqlite3_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_reopen.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_reopen", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vtab_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_config", + " function" + )))(arg1, op, vararg1) +} + +pub unsafe fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_on_conflict.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_on_conflict", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close_v2", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_db_filename( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_filename.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_filename", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_db_readonly( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_readonly.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_readonly", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errstr.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errstr", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_busy.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_busy", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stmt_readonly(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_readonly.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_readonly", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stricmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stricmp.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stricmp", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_uri_boolean( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_boolean.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_boolean", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_uri_int64( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64, +) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_uri_parameter( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_parameter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_parameter", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vsnprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vsnprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vsnprintf", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_wal_checkpoint_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_checkpoint_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_checkpoint_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_auto_extension( + arg1: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).auto_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "auto_extension", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob64", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_text64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + arg6: ::std::os::raw::c_uchar, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text64", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_cancel_auto_extension( + arg1: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).cancel_auto_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "cancel_auto_extension", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_load_extension( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).load_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "load_extension", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_malloc64(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_msize(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).msize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "msize", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_realloc64( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_uint64, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset_auto_extension() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset_auto_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset_auto_extension", + " function" + )))() +} + +pub unsafe fn sqlite3_result_blob64( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob64", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text64( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + arg5: ::std::os::raw::c_uchar, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text64", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_strglob( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strglob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strglob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_value_dup(arg1: *const sqlite3_value) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_dup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_dup", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_free(arg1: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_zeroblob64( + arg1: *mut sqlite3_context, + arg2: sqlite3_uint64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_zeroblob64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_uint64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_value_subtype(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_subtype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_subtype", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_subtype(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_subtype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_subtype", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_status64( + arg1: ::std::os::raw::c_int, + arg2: *mut sqlite3_int64, + arg3: *mut sqlite3_int64, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status64", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_strlike( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_uint, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strlike.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strlike", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_db_cacheflush(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_cacheflush.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_cacheflush", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_system_errno(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).system_errno.expect(stringify!( + "sqlite3_api contains null pointer for ", + "system_errno", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_trace_v2( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_uint, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_uint, + arg2: *mut ::std::os::raw::c_void, + arg3: *mut ::std::os::raw::c_void, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).trace_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "trace_v2", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_expanded_sql(arg1: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).expanded_sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "expanded_sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_set_last_insert_rowid(arg1: *mut sqlite3, arg2: sqlite3_int64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_last_insert_rowid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_last_insert_rowid", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_prepare_v3( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_uint, + arg5: *mut *mut sqlite3_stmt, + arg6: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare_v3.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare_v3", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_prepare16_v3( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_uint, + arg5: *mut *mut sqlite3_stmt, + arg6: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16_v3.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16_v3", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_bind_pointer( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: *const ::std::os::raw::c_char, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_pointer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_pointer", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_result_pointer( + arg1: *mut sqlite3_context, + arg2: *mut ::std::os::raw::c_void, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_pointer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_pointer", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_value_pointer( + arg1: *mut sqlite3_value, + arg2: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_pointer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_pointer", + " function" + )))(arg1, arg2) +} diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.20.0.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.20.0.rs new file mode 100644 index 000000000..835532f5f --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.20.0.rs @@ -0,0 +1,5030 @@ +/* automatically generated by rust-bindgen */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.20.0\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3020000; +pub const SQLITE_SOURCE_ID: &'static [u8; 85usize] = + b"2017-08-01 13:24:15 9501e22dfeebdcefa783575e47c60b514d7c2e0cad73b2a496c0bc4b680900a8\0"; +pub const SQLITE_OK: i32 = 0; +pub const SQLITE_ERROR: i32 = 1; +pub const SQLITE_INTERNAL: i32 = 2; +pub const SQLITE_PERM: i32 = 3; +pub const SQLITE_ABORT: i32 = 4; +pub const SQLITE_BUSY: i32 = 5; +pub const SQLITE_LOCKED: i32 = 6; +pub const SQLITE_NOMEM: i32 = 7; +pub const SQLITE_READONLY: i32 = 8; +pub const SQLITE_INTERRUPT: i32 = 9; +pub const SQLITE_IOERR: i32 = 10; +pub const SQLITE_CORRUPT: i32 = 11; +pub const SQLITE_NOTFOUND: i32 = 12; +pub const SQLITE_FULL: i32 = 13; +pub const SQLITE_CANTOPEN: i32 = 14; +pub const SQLITE_PROTOCOL: i32 = 15; +pub const SQLITE_EMPTY: i32 = 16; +pub const SQLITE_SCHEMA: i32 = 17; +pub const SQLITE_TOOBIG: i32 = 18; +pub const SQLITE_CONSTRAINT: i32 = 19; +pub const SQLITE_MISMATCH: i32 = 20; +pub const SQLITE_MISUSE: i32 = 21; +pub const SQLITE_NOLFS: i32 = 22; +pub const SQLITE_AUTH: i32 = 23; +pub const SQLITE_FORMAT: i32 = 24; +pub const SQLITE_RANGE: i32 = 25; +pub const SQLITE_NOTADB: i32 = 26; +pub const SQLITE_NOTICE: i32 = 27; +pub const SQLITE_WARNING: i32 = 28; +pub const SQLITE_ROW: i32 = 100; +pub const SQLITE_DONE: i32 = 101; +pub const SQLITE_IOERR_READ: i32 = 266; +pub const SQLITE_IOERR_SHORT_READ: i32 = 522; +pub const SQLITE_IOERR_WRITE: i32 = 778; +pub const SQLITE_IOERR_FSYNC: i32 = 1034; +pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; +pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; +pub const SQLITE_IOERR_FSTAT: i32 = 1802; +pub const SQLITE_IOERR_UNLOCK: i32 = 2058; +pub const SQLITE_IOERR_RDLOCK: i32 = 2314; +pub const SQLITE_IOERR_DELETE: i32 = 2570; +pub const SQLITE_IOERR_BLOCKED: i32 = 2826; +pub const SQLITE_IOERR_NOMEM: i32 = 3082; +pub const SQLITE_IOERR_ACCESS: i32 = 3338; +pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; +pub const SQLITE_IOERR_LOCK: i32 = 3850; +pub const SQLITE_IOERR_CLOSE: i32 = 4106; +pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; +pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; +pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; +pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; +pub const SQLITE_IOERR_SHMMAP: i32 = 5386; +pub const SQLITE_IOERR_SEEK: i32 = 5642; +pub const SQLITE_IOERR_DELETE_NOENT: i32 = 5898; +pub const SQLITE_IOERR_MMAP: i32 = 6154; +pub const SQLITE_IOERR_GETTEMPPATH: i32 = 6410; +pub const SQLITE_IOERR_CONVPATH: i32 = 6666; +pub const SQLITE_IOERR_VNODE: i32 = 6922; +pub const SQLITE_IOERR_AUTH: i32 = 7178; +pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; +pub const SQLITE_BUSY_RECOVERY: i32 = 261; +pub const SQLITE_BUSY_SNAPSHOT: i32 = 517; +pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; +pub const SQLITE_CANTOPEN_ISDIR: i32 = 526; +pub const SQLITE_CANTOPEN_FULLPATH: i32 = 782; +pub const SQLITE_CANTOPEN_CONVPATH: i32 = 1038; +pub const SQLITE_CORRUPT_VTAB: i32 = 267; +pub const SQLITE_READONLY_RECOVERY: i32 = 264; +pub const SQLITE_READONLY_CANTLOCK: i32 = 520; +pub const SQLITE_READONLY_ROLLBACK: i32 = 776; +pub const SQLITE_READONLY_DBMOVED: i32 = 1032; +pub const SQLITE_ABORT_ROLLBACK: i32 = 516; +pub const SQLITE_CONSTRAINT_CHECK: i32 = 275; +pub const SQLITE_CONSTRAINT_COMMITHOOK: i32 = 531; +pub const SQLITE_CONSTRAINT_FOREIGNKEY: i32 = 787; +pub const SQLITE_CONSTRAINT_FUNCTION: i32 = 1043; +pub const SQLITE_CONSTRAINT_NOTNULL: i32 = 1299; +pub const SQLITE_CONSTRAINT_PRIMARYKEY: i32 = 1555; +pub const SQLITE_CONSTRAINT_TRIGGER: i32 = 1811; +pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067; +pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323; +pub const SQLITE_CONSTRAINT_ROWID: i32 = 2579; +pub const SQLITE_NOTICE_RECOVER_WAL: i32 = 283; +pub const SQLITE_NOTICE_RECOVER_ROLLBACK: i32 = 539; +pub const SQLITE_WARNING_AUTOINDEX: i32 = 284; +pub const SQLITE_AUTH_USER: i32 = 279; +pub const SQLITE_OK_LOAD_PERMANENTLY: i32 = 256; +pub const SQLITE_OPEN_READONLY: i32 = 1; +pub const SQLITE_OPEN_READWRITE: i32 = 2; +pub const SQLITE_OPEN_CREATE: i32 = 4; +pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; +pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; +pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; +pub const SQLITE_OPEN_URI: i32 = 64; +pub const SQLITE_OPEN_MEMORY: i32 = 128; +pub const SQLITE_OPEN_MAIN_DB: i32 = 256; +pub const SQLITE_OPEN_TEMP_DB: i32 = 512; +pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; +pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; +pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; +pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; +pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; +pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; +pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; +pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; +pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; +pub const SQLITE_OPEN_WAL: i32 = 524288; +pub const SQLITE_IOCAP_ATOMIC: i32 = 1; +pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; +pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; +pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; +pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; +pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; +pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; +pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; +pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; +pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; +pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; +pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; +pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE: i32 = 4096; +pub const SQLITE_IOCAP_IMMUTABLE: i32 = 8192; +pub const SQLITE_LOCK_NONE: i32 = 0; +pub const SQLITE_LOCK_SHARED: i32 = 1; +pub const SQLITE_LOCK_RESERVED: i32 = 2; +pub const SQLITE_LOCK_PENDING: i32 = 3; +pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; +pub const SQLITE_SYNC_NORMAL: i32 = 2; +pub const SQLITE_SYNC_FULL: i32 = 3; +pub const SQLITE_SYNC_DATAONLY: i32 = 16; +pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; +pub const SQLITE_FCNTL_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_FCNTL_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_FCNTL_LAST_ERRNO: i32 = 4; +pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; +pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; +pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; +pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; +pub const SQLITE_FCNTL_WIN32_AV_RETRY: i32 = 9; +pub const SQLITE_FCNTL_PERSIST_WAL: i32 = 10; +pub const SQLITE_FCNTL_OVERWRITE: i32 = 11; +pub const SQLITE_FCNTL_VFSNAME: i32 = 12; +pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE: i32 = 13; +pub const SQLITE_FCNTL_PRAGMA: i32 = 14; +pub const SQLITE_FCNTL_BUSYHANDLER: i32 = 15; +pub const SQLITE_FCNTL_TEMPFILENAME: i32 = 16; +pub const SQLITE_FCNTL_MMAP_SIZE: i32 = 18; +pub const SQLITE_FCNTL_TRACE: i32 = 19; +pub const SQLITE_FCNTL_HAS_MOVED: i32 = 20; +pub const SQLITE_FCNTL_SYNC: i32 = 21; +pub const SQLITE_FCNTL_COMMIT_PHASETWO: i32 = 22; +pub const SQLITE_FCNTL_WIN32_SET_HANDLE: i32 = 23; +pub const SQLITE_FCNTL_WAL_BLOCK: i32 = 24; +pub const SQLITE_FCNTL_ZIPVFS: i32 = 25; +pub const SQLITE_FCNTL_RBU: i32 = 26; +pub const SQLITE_FCNTL_VFS_POINTER: i32 = 27; +pub const SQLITE_FCNTL_JOURNAL_POINTER: i32 = 28; +pub const SQLITE_FCNTL_WIN32_GET_HANDLE: i32 = 29; +pub const SQLITE_FCNTL_PDB: i32 = 30; +pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_LAST_ERRNO: i32 = 4; +pub const SQLITE_ACCESS_EXISTS: i32 = 0; +pub const SQLITE_ACCESS_READWRITE: i32 = 1; +pub const SQLITE_ACCESS_READ: i32 = 2; +pub const SQLITE_SHM_UNLOCK: i32 = 1; +pub const SQLITE_SHM_LOCK: i32 = 2; +pub const SQLITE_SHM_SHARED: i32 = 4; +pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; +pub const SQLITE_SHM_NLOCK: i32 = 8; +pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; +pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; +pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; +pub const SQLITE_CONFIG_MALLOC: i32 = 4; +pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; +pub const SQLITE_CONFIG_SCRATCH: i32 = 6; +pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; +pub const SQLITE_CONFIG_HEAP: i32 = 8; +pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; +pub const SQLITE_CONFIG_MUTEX: i32 = 10; +pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; +pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; +pub const SQLITE_CONFIG_PCACHE: i32 = 14; +pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; +pub const SQLITE_CONFIG_LOG: i32 = 16; +pub const SQLITE_CONFIG_URI: i32 = 17; +pub const SQLITE_CONFIG_PCACHE2: i32 = 18; +pub const SQLITE_CONFIG_GETPCACHE2: i32 = 19; +pub const SQLITE_CONFIG_COVERING_INDEX_SCAN: i32 = 20; +pub const SQLITE_CONFIG_SQLLOG: i32 = 21; +pub const SQLITE_CONFIG_MMAP_SIZE: i32 = 22; +pub const SQLITE_CONFIG_WIN32_HEAPSIZE: i32 = 23; +pub const SQLITE_CONFIG_PCACHE_HDRSZ: i32 = 24; +pub const SQLITE_CONFIG_PMASZ: i32 = 25; +pub const SQLITE_CONFIG_STMTJRNL_SPILL: i32 = 26; +pub const SQLITE_DBCONFIG_MAINDBNAME: i32 = 1000; +pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; +pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; +pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; +pub const SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: i32 = 1004; +pub const SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: i32 = 1005; +pub const SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE: i32 = 1006; +pub const SQLITE_DBCONFIG_ENABLE_QPSG: i32 = 1007; +pub const SQLITE_DENY: i32 = 1; +pub const SQLITE_IGNORE: i32 = 2; +pub const SQLITE_CREATE_INDEX: i32 = 1; +pub const SQLITE_CREATE_TABLE: i32 = 2; +pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; +pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; +pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; +pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; +pub const SQLITE_CREATE_TRIGGER: i32 = 7; +pub const SQLITE_CREATE_VIEW: i32 = 8; +pub const SQLITE_DELETE: i32 = 9; +pub const SQLITE_DROP_INDEX: i32 = 10; +pub const SQLITE_DROP_TABLE: i32 = 11; +pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; +pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; +pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; +pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; +pub const SQLITE_DROP_TRIGGER: i32 = 16; +pub const SQLITE_DROP_VIEW: i32 = 17; +pub const SQLITE_INSERT: i32 = 18; +pub const SQLITE_PRAGMA: i32 = 19; +pub const SQLITE_READ: i32 = 20; +pub const SQLITE_SELECT: i32 = 21; +pub const SQLITE_TRANSACTION: i32 = 22; +pub const SQLITE_UPDATE: i32 = 23; +pub const SQLITE_ATTACH: i32 = 24; +pub const SQLITE_DETACH: i32 = 25; +pub const SQLITE_ALTER_TABLE: i32 = 26; +pub const SQLITE_REINDEX: i32 = 27; +pub const SQLITE_ANALYZE: i32 = 28; +pub const SQLITE_CREATE_VTABLE: i32 = 29; +pub const SQLITE_DROP_VTABLE: i32 = 30; +pub const SQLITE_FUNCTION: i32 = 31; +pub const SQLITE_SAVEPOINT: i32 = 32; +pub const SQLITE_COPY: i32 = 0; +pub const SQLITE_RECURSIVE: i32 = 33; +pub const SQLITE_TRACE_STMT: i32 = 1; +pub const SQLITE_TRACE_PROFILE: i32 = 2; +pub const SQLITE_TRACE_ROW: i32 = 4; +pub const SQLITE_TRACE_CLOSE: i32 = 8; +pub const SQLITE_LIMIT_LENGTH: i32 = 0; +pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; +pub const SQLITE_LIMIT_COLUMN: i32 = 2; +pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; +pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; +pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; +pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; +pub const SQLITE_LIMIT_ATTACHED: i32 = 7; +pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; +pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; +pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; +pub const SQLITE_LIMIT_WORKER_THREADS: i32 = 11; +pub const SQLITE_PREPARE_PERSISTENT: i32 = 1; +pub const SQLITE_INTEGER: i32 = 1; +pub const SQLITE_FLOAT: i32 = 2; +pub const SQLITE_BLOB: i32 = 4; +pub const SQLITE_NULL: i32 = 5; +pub const SQLITE_TEXT: i32 = 3; +pub const SQLITE3_TEXT: i32 = 3; +pub const SQLITE_UTF8: i32 = 1; +pub const SQLITE_UTF16LE: i32 = 2; +pub const SQLITE_UTF16BE: i32 = 3; +pub const SQLITE_UTF16: i32 = 4; +pub const SQLITE_ANY: i32 = 5; +pub const SQLITE_UTF16_ALIGNED: i32 = 8; +pub const SQLITE_DETERMINISTIC: i32 = 2048; +pub const SQLITE_INDEX_SCAN_UNIQUE: i32 = 1; +pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; +pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; +pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; +pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; +pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; +pub const SQLITE_INDEX_CONSTRAINT_LIKE: i32 = 65; +pub const SQLITE_INDEX_CONSTRAINT_GLOB: i32 = 66; +pub const SQLITE_INDEX_CONSTRAINT_REGEXP: i32 = 67; +pub const SQLITE_MUTEX_FAST: i32 = 0; +pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; +pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; +pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; +pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; +pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; +pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; +pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; +pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; +pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; +pub const SQLITE_MUTEX_STATIC_APP1: i32 = 8; +pub const SQLITE_MUTEX_STATIC_APP2: i32 = 9; +pub const SQLITE_MUTEX_STATIC_APP3: i32 = 10; +pub const SQLITE_MUTEX_STATIC_VFS1: i32 = 11; +pub const SQLITE_MUTEX_STATIC_VFS2: i32 = 12; +pub const SQLITE_MUTEX_STATIC_VFS3: i32 = 13; +pub const SQLITE_TESTCTRL_FIRST: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; +pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; +pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; +pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; +pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; +pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; +pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; +pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; +pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; +pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; +pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; +pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 17; +pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 18; +pub const SQLITE_TESTCTRL_EXPLAIN_STMT: i32 = 19; +pub const SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD: i32 = 19; +pub const SQLITE_TESTCTRL_NEVER_CORRUPT: i32 = 20; +pub const SQLITE_TESTCTRL_VDBE_COVERAGE: i32 = 21; +pub const SQLITE_TESTCTRL_BYTEORDER: i32 = 22; +pub const SQLITE_TESTCTRL_ISINIT: i32 = 23; +pub const SQLITE_TESTCTRL_SORTER_MMAP: i32 = 24; +pub const SQLITE_TESTCTRL_IMPOSTER: i32 = 25; +pub const SQLITE_TESTCTRL_LAST: i32 = 25; +pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; +pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; +pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; +pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; +pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; +pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; +pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; +pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; +pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; +pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; +pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; +pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; +pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; +pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; +pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; +pub const SQLITE_DBSTATUS_CACHE_HIT: i32 = 7; +pub const SQLITE_DBSTATUS_CACHE_MISS: i32 = 8; +pub const SQLITE_DBSTATUS_CACHE_WRITE: i32 = 9; +pub const SQLITE_DBSTATUS_DEFERRED_FKS: i32 = 10; +pub const SQLITE_DBSTATUS_CACHE_USED_SHARED: i32 = 11; +pub const SQLITE_DBSTATUS_MAX: i32 = 11; +pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; +pub const SQLITE_STMTSTATUS_SORT: i32 = 2; +pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; +pub const SQLITE_STMTSTATUS_VM_STEP: i32 = 4; +pub const SQLITE_STMTSTATUS_REPREPARE: i32 = 5; +pub const SQLITE_STMTSTATUS_RUN: i32 = 6; +pub const SQLITE_STMTSTATUS_MEMUSED: i32 = 99; +pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; +pub const SQLITE_CHECKPOINT_FULL: i32 = 1; +pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; +pub const SQLITE_CHECKPOINT_TRUNCATE: i32 = 3; +pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; +pub const SQLITE_ROLLBACK: i32 = 1; +pub const SQLITE_FAIL: i32 = 3; +pub const SQLITE_REPLACE: i32 = 5; +pub const SQLITE_SCANSTAT_NLOOP: i32 = 0; +pub const SQLITE_SCANSTAT_NVISIT: i32 = 1; +pub const SQLITE_SCANSTAT_EST: i32 = 2; +pub const SQLITE_SCANSTAT_NAME: i32 = 3; +pub const SQLITE_SCANSTAT_EXPLAIN: i32 = 4; +pub const SQLITE_SCANSTAT_SELECTID: i32 = 5; +pub const NOT_WITHIN: i32 = 0; +pub const PARTLY_WITHIN: i32 = 1; +pub const FULLY_WITHIN: i32 = 2; +pub const FTS5_TOKENIZE_QUERY: i32 = 1; +pub const FTS5_TOKENIZE_PREFIX: i32 = 2; +pub const FTS5_TOKENIZE_DOCUMENT: i32 = 4; +pub const FTS5_TOKENIZE_AUX: i32 = 8; +pub const FTS5_TOKEN_COLOCATED: i32 = 1; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; +extern "C" { + #[link_name = "\u{1}sqlite3_version"] + pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; +} +extern "C" { + pub fn sqlite3_libversion() -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_sourceid() -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_libversion_number() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_compileoption_used( + zOptName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_compileoption_get(N: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_threadsafe() -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3 { + _unused: [u8; 0], +} +pub type sqlite_int64 = ::std::os::raw::c_longlong; +pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; +pub type sqlite3_int64 = sqlite_int64; +pub type sqlite3_uint64 = sqlite_uint64; +extern "C" { + pub fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +extern "C" { + pub fn sqlite3_exec( + arg1: *mut sqlite3, + sql: *const ::std::os::raw::c_char, + callback: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg2: *mut ::std::os::raw::c_void, + errmsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_file { + pub pMethods: *const sqlite3_io_methods, +} +#[test] +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xShmMap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iPg: ::std::os::raw::c_int, + pgsz: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xShmLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + offset: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xShmBarrier: ::std::option::Option, + pub xShmUnmap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + deleteFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iOfst: sqlite3_int64, + iAmt: ::std::os::raw::c_int, + pp: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xUnfetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iOfst: sqlite3_int64, + p: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 152usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmMap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmBarrier) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmUnmap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnfetch as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnfetch) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_api_routines { + _unused: [u8; 0], +} +pub type sqlite3_syscall_ptr = ::std::option::Option; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vfs { + pub iVersion: ::std::os::raw::c_int, + pub szOsFile: ::std::os::raw::c_int, + pub mxPathname: ::std::os::raw::c_int, + pub pNext: *mut sqlite3_vfs, + pub zName: *const ::std::os::raw::c_char, + pub pAppData: *mut ::std::os::raw::c_void, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTimeInt64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xSetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: sqlite3_syscall_ptr, + ) -> ::std::os::raw::c_int, + >, + pub xGetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> sqlite3_syscall_ptr, + >, + pub xNextSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_vfs() { + assert_eq!( + ::std::mem::size_of::(), + 168usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTimeInt64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xNextSystemCall) + ) + ); +} +extern "C" { + pub fn sqlite3_initialize() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_shutdown() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_os_init() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_os_end() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_db_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mem_methods { + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub pAppData: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_mem_methods() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +extern "C" { + pub fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + onoff: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_set_last_insert_rowid(arg1: *mut sqlite3, arg2: sqlite3_int64); +} +extern "C" { + pub fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_interrupt(arg1: *mut sqlite3); +} +extern "C" { + pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_get_table( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + pazResult: *mut *mut *mut ::std::os::raw::c_char, + pnRow: *mut ::std::os::raw::c_int, + pnColumn: *mut ::std::os::raw::c_int, + pzErrmsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char); +} +extern "C" { + pub fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char, ...) + -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_snprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_vsnprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_malloc64(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_realloc64( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_uint64, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_free(arg1: *mut ::std::os::raw::c_void); +} +extern "C" { + pub fn sqlite3_msize(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64; +} +extern "C" { + pub fn sqlite3_memory_used() -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_randomness(N: ::std::os::raw::c_int, P: *mut ::std::os::raw::c_void); +} +extern "C" { + pub fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + xAuth: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pUserData: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_profile( + arg1: *mut sqlite3, + xProfile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_trace_v2( + arg1: *mut sqlite3, + uMask: ::std::os::raw::c_uint, + xCallback: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_uint, + arg2: *mut ::std::os::raw::c_void, + arg3: *mut ::std::os::raw::c_void, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pCtx: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + pub fn sqlite3_open( + filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_open16( + filename: *const ::std::os::raw::c_void, + ppDb: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_open_v2( + filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3, + flags: ::std::os::raw::c_int, + zVfs: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_uri_parameter( + zFilename: *const ::std::os::raw::c_char, + zParam: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_uri_boolean( + zFile: *const ::std::os::raw::c_char, + zParam: *const ::std::os::raw::c_char, + bDefault: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_uri_int64( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64, + ) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_extended_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_stmt { + _unused: [u8; 0], +} +extern "C" { + pub fn sqlite3_limit( + arg1: *mut sqlite3, + id: ::std::os::raw::c_int, + newVal: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_prepare( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_prepare_v2( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_prepare_v3( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + prepFlags: ::std::os::raw::c_uint, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_prepare16( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_prepare16_v2( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_prepare16_v3( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + prepFlags: ::std::os::raw::c_uint, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_expanded_sql(pStmt: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_stmt_readonly(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_value { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_context { + _unused: [u8; 0], +} +extern "C" { + pub fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_blob64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_int64, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_text64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + encoding: ::std::os::raw::c_uchar, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_pointer( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: *const ::std::os::raw::c_char, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_zeroblob64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_uint64, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64; +} +extern "C" { + pub fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar; +} +extern "C" { + pub fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value; +} +extern "C" { + pub fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function16( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_void, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function_v2( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_global_recover() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_thread_cleanup(); +} +extern "C" { + pub fn sqlite3_memory_alarm( + arg1: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_int64, + arg3: ::std::os::raw::c_int, + ), + >, + arg2: *mut ::std::os::raw::c_void, + arg3: sqlite3_int64, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64; +} +extern "C" { + pub fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_value_pointer( + arg1: *mut sqlite3_value, + arg2: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar; +} +extern "C" { + pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_subtype(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint; +} +extern "C" { + pub fn sqlite3_value_dup(arg1: *const sqlite3_value) -> *mut sqlite3_value; +} +extern "C" { + pub fn sqlite3_value_free(arg1: *mut sqlite3_value); +} +extern "C" { + pub fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3; +} +extern "C" { + pub fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option, + ); +} +pub type sqlite3_destructor_type = + ::std::option::Option; +extern "C" { + pub fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_blob64( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64); +} +extern "C" { + pub fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context); +} +extern "C" { + pub fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context); +} +extern "C" { + pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite3_int64); +} +extern "C" { + pub fn sqlite3_result_null(arg1: *mut sqlite3_context); +} +extern "C" { + pub fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text64( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + encoding: ::std::os::raw::c_uchar, + ); +} +extern "C" { + pub fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value); +} +extern "C" { + pub fn sqlite3_result_pointer( + arg1: *mut sqlite3_context, + arg2: *mut ::std::os::raw::c_void, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, n: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_result_zeroblob64( + arg1: *mut sqlite3_context, + n: sqlite3_uint64, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_result_subtype(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint); +} +extern "C" { + pub fn sqlite3_create_collation( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation16( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_void, + eTextRep: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "\u{1}sqlite3_temp_directory"] + pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "\u{1}sqlite3_data_directory"] + pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3; +} +extern "C" { + pub fn sqlite3_db_filename( + db: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_db_readonly( + db: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) -> *mut sqlite3_stmt; +} +extern "C" { + pub fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_soft_heap_limit64(N: sqlite3_int64) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_soft_heap_limit(N: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_table_column_metadata( + db: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + zTableName: *const ::std::os::raw::c_char, + zColumnName: *const ::std::os::raw::c_char, + pzDataType: *mut *const ::std::os::raw::c_char, + pzCollSeq: *mut *const ::std::os::raw::c_char, + pNotNull: *mut ::std::os::raw::c_int, + pPrimaryKey: *mut ::std::os::raw::c_int, + pAutoinc: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_load_extension( + db: *mut sqlite3, + zFile: *const ::std::os::raw::c_char, + zProc: *const ::std::os::raw::c_char, + pzErrMsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_enable_load_extension( + db: *mut sqlite3, + onoff: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_auto_extension( + xEntryPoint: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_cancel_auto_extension( + xEntryPoint: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_reset_auto_extension(); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSavepoint: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRelease: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRollbackTo: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 184usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSavepoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRelease) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollbackTo) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info { + pub nConstraint: ::std::os::raw::c_int, + pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, + pub nOrderBy: ::std::os::raw::c_int, + pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, + pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, + pub idxNum: ::std::os::raw::c_int, + pub idxStr: *mut ::std::os::raw::c_char, + pub needToFreeIdxStr: ::std::os::raw::c_int, + pub orderByConsumed: ::std::os::raw::c_int, + pub estimatedCost: f64, + pub estimatedRows: sqlite3_int64, + pub idxFlags: ::std::os::raw::c_int, + pub colUsed: sqlite3_uint64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint { + pub iColumn: ::std::os::raw::c_int, + pub op: ::std::os::raw::c_uchar, + pub usable: ::std::os::raw::c_uchar, + pub iTermOffset: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_orderby { + pub iColumn: ::std::os::raw::c_int, + pub desc: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint_usage { + pub argvIndex: ::std::os::raw::c_int, + pub omit: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); +} +#[test] +fn bindgen_test_layout_sqlite3_index_info() { + assert_eq!( + ::std::mem::size_of::(), + 96usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedRows as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedRows) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxFlags as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxFlags) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).colUsed as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(colUsed) + ) + ); +} +extern "C" { + pub fn sqlite3_create_module( + db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + p: *const sqlite3_module, + pClientData: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_module_v2( + db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + p: *const sqlite3_module, + pClientData: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +extern "C" { + pub fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + zSQL: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_blob { + _unused: [u8; 0], +} +extern "C" { + pub fn sqlite3_blob_open( + arg1: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + zTable: *const ::std::os::raw::c_char, + zColumn: *const ::std::os::raw::c_char, + iRow: sqlite3_int64, + flags: ::std::os::raw::c_int, + ppBlob: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_blob_reopen( + arg1: *mut sqlite3_blob, + arg2: sqlite3_int64, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + Z: *mut ::std::os::raw::c_void, + N: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + z: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs; +} +extern "C" { + pub fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + makeDflt: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex; +} +extern "C" { + pub fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex); +} +extern "C" { + pub fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex); +} +extern "C" { + pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex_methods { + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_mutex_methods() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +extern "C" { + pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex; +} +extern "C" { + pub fn sqlite3_file_control( + arg1: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + op: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_status( + op: ::std::os::raw::c_int, + pCurrent: *mut ::std::os::raw::c_int, + pHighwater: *mut ::std::os::raw::c_int, + resetFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_status64( + op: ::std::os::raw::c_int, + pCurrent: *mut sqlite3_int64, + pHighwater: *mut sqlite3_int64, + resetFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_db_status( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + pCur: *mut ::std::os::raw::c_int, + pHiwtr: *mut ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_stmt_status( + arg1: *mut sqlite3_stmt, + op: ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_page { + pub pBuf: *mut ::std::os::raw::c_void, + pub pExtra: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_page() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pBuf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pExtra) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods2 { + pub iVersion: ::std::os::raw::c_int, + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + szExtra: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache_page, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, + pub xShrink: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods2() { + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iVersion as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDestroy as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShrink) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods { + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_backup { + _unused: [u8; 0], +} +extern "C" { + pub fn sqlite3_backup_init( + pDest: *mut sqlite3, + zDestName: *const ::std::os::raw::c_char, + pSource: *mut sqlite3, + zSourceName: *const ::std::os::raw::c_char, + ) -> *mut sqlite3_backup; +} +extern "C" { + pub fn sqlite3_backup_step( + p: *mut sqlite3_backup, + nPage: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_backup_finish(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_backup_remaining(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_backup_pagecount(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_unlock_notify( + pBlocked: *mut sqlite3, + xNotify: ::std::option::Option< + unsafe extern "C" fn( + apArg: *mut *mut ::std::os::raw::c_void, + nArg: ::std::os::raw::c_int, + ), + >, + pNotifyArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_stricmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_strnicmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_strglob( + zGlob: *const ::std::os::raw::c_char, + zStr: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_strlike( + zGlob: *const ::std::os::raw::c_char, + zStr: *const ::std::os::raw::c_char, + cEsc: ::std::os::raw::c_uint, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_log( + iErrCode: ::std::os::raw::c_int, + zFormat: *const ::std::os::raw::c_char, + ... + ); +} +extern "C" { + pub fn sqlite3_wal_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_wal_autocheckpoint( + db: *mut sqlite3, + N: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_wal_checkpoint( + db: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_wal_checkpoint_v2( + db: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + eMode: ::std::os::raw::c_int, + pnLog: *mut ::std::os::raw::c_int, + pnCkpt: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_vtab_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_stmt_scanstatus( + pStmt: *mut sqlite3_stmt, + idx: ::std::os::raw::c_int, + iScanStatusOp: ::std::os::raw::c_int, + pOut: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_stmt_scanstatus_reset(arg1: *mut sqlite3_stmt); +} +extern "C" { + pub fn sqlite3_db_cacheflush(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_system_errno(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct sqlite3_snapshot { + pub hidden: [::std::os::raw::c_uchar; 48usize], +} +#[test] +fn bindgen_test_layout_sqlite3_snapshot() { + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!("Size of: ", stringify!(sqlite3_snapshot)) + ); + assert_eq!( + ::std::mem::align_of::(), + 1usize, + concat!("Alignment of ", stringify!(sqlite3_snapshot)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).hidden as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_snapshot), + "::", + stringify!(hidden) + ) + ); +} +extern "C" { + pub fn sqlite3_snapshot_get( + db: *mut sqlite3, + zSchema: *const ::std::os::raw::c_char, + ppSnapshot: *mut *mut sqlite3_snapshot, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_snapshot_open( + db: *mut sqlite3, + zSchema: *const ::std::os::raw::c_char, + pSnapshot: *mut sqlite3_snapshot, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_snapshot_free(arg1: *mut sqlite3_snapshot); +} +extern "C" { + pub fn sqlite3_snapshot_cmp( + p1: *mut sqlite3_snapshot, + p2: *mut sqlite3_snapshot, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_snapshot_recover( + db: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +pub type sqlite3_rtree_dbl = f64; +extern "C" { + pub fn sqlite3_rtree_geometry_callback( + db: *mut sqlite3, + zGeom: *const ::std::os::raw::c_char, + xGeom: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_rtree_geometry, + arg2: ::std::os::raw::c_int, + arg3: *mut sqlite3_rtree_dbl, + arg4: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pContext: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_geometry { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut sqlite3_rtree_dbl, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_geometry() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(xDelUser) + ) + ); +} +extern "C" { + pub fn sqlite3_rtree_query_callback( + db: *mut sqlite3, + zQueryFunc: *const ::std::os::raw::c_char, + xQueryFunc: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_rtree_query_info) -> ::std::os::raw::c_int, + >, + pContext: *mut ::std::os::raw::c_void, + xDestructor: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_query_info { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut sqlite3_rtree_dbl, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, + pub aCoord: *mut sqlite3_rtree_dbl, + pub anQueue: *mut ::std::os::raw::c_uint, + pub nCoord: ::std::os::raw::c_int, + pub iLevel: ::std::os::raw::c_int, + pub mxLevel: ::std::os::raw::c_int, + pub iRowid: sqlite3_int64, + pub rParentScore: sqlite3_rtree_dbl, + pub eParentWithin: ::std::os::raw::c_int, + pub eWithin: ::std::os::raw::c_int, + pub rScore: sqlite3_rtree_dbl, + pub apSqlParam: *mut *mut sqlite3_value, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_query_info() { + assert_eq!( + ::std::mem::size_of::(), + 112usize, + concat!("Size of: ", stringify!(sqlite3_rtree_query_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_query_info)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).pContext as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDelUser as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(xDelUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aCoord as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(aCoord) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).anQueue as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(anQueue) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nCoord as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(nCoord) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iLevel as *const _ as usize }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(iLevel) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mxLevel as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(mxLevel) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iRowid as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(iRowid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rParentScore as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(rParentScore) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eParentWithin as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(eParentWithin) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eWithin as *const _ as usize + }, + 92usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(eWithin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).rScore as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(rScore) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).apSqlParam as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(apSqlParam) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5Context { + _unused: [u8; 0], +} +pub type fts5_extension_function = ::std::option::Option< + unsafe extern "C" fn( + pApi: *const Fts5ExtensionApi, + pFts: *mut Fts5Context, + pCtx: *mut sqlite3_context, + nVal: ::std::os::raw::c_int, + apVal: *mut *mut sqlite3_value, + ), +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5PhraseIter { + pub a: *const ::std::os::raw::c_uchar, + pub b: *const ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_Fts5PhraseIter() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Fts5PhraseIter)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Fts5PhraseIter)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).a as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Fts5PhraseIter), + "::", + stringify!(a) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).b as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Fts5PhraseIter), + "::", + stringify!(b) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5ExtensionApi { + pub iVersion: ::std::os::raw::c_int, + pub xUserData: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> *mut ::std::os::raw::c_void, + >, + pub xColumnCount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, + >, + pub xRowCount: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pnRow: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xColumnTotalSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pnToken: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTokenize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pText: *const ::std::os::raw::c_char, + nText: ::std::os::raw::c_int, + pCtx: *mut ::std::os::raw::c_void, + xToken: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + arg6: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseCount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, + >, + pub xPhraseSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xInstCount: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pnInst: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xInst: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iIdx: ::std::os::raw::c_int, + piPhrase: *mut ::std::os::raw::c_int, + piCol: *mut ::std::os::raw::c_int, + piOff: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: + ::std::option::Option sqlite3_int64>, + pub xColumnText: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pz: *mut *const ::std::os::raw::c_char, + pn: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xColumnSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pnToken: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xQueryPhrase: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + pUserData: *mut ::std::os::raw::c_void, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const Fts5ExtensionApi, + arg2: *mut Fts5Context, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub xSetAuxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pAux: *mut ::std::os::raw::c_void, + xDelete: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub xGetAuxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + bClear: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xPhraseFirst: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + arg2: *mut Fts5PhraseIter, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseNext: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + arg2: *mut Fts5PhraseIter, + piCol: *mut ::std::os::raw::c_int, + piOff: *mut ::std::os::raw::c_int, + ), + >, + pub xPhraseFirstColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + arg2: *mut Fts5PhraseIter, + arg3: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseNextColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + arg2: *mut Fts5PhraseIter, + piCol: *mut ::std::os::raw::c_int, + ), + >, +} +#[test] +fn bindgen_test_layout_Fts5ExtensionApi() { + assert_eq!( + ::std::mem::size_of::(), + 160usize, + concat!("Size of: ", stringify!(Fts5ExtensionApi)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Fts5ExtensionApi)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUserData as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xUserData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnCount as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowCount as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xRowCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xColumnTotalSize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnTotalSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xTokenize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseCount as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseSize as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInstCount as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xInstCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInst as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xInst) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnText as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnText) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnSize as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xQueryPhrase as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xQueryPhrase) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetAuxdata as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xSetAuxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetAuxdata as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xGetAuxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseFirst as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseFirst) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseNext as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseNext) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPhraseFirstColumn as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseFirstColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPhraseNextColumn as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseNextColumn) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5Tokenizer { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct fts5_tokenizer { + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + azArg: *mut *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ppOut: *mut *mut Fts5Tokenizer, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option, + pub xTokenize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Tokenizer, + pCtx: *mut ::std::os::raw::c_void, + flags: ::std::os::raw::c_int, + pText: *const ::std::os::raw::c_char, + nText: ::std::os::raw::c_int, + xToken: ::std::option::Option< + unsafe extern "C" fn( + pCtx: *mut ::std::os::raw::c_void, + tflags: ::std::os::raw::c_int, + pToken: *const ::std::os::raw::c_char, + nToken: ::std::os::raw::c_int, + iStart: ::std::os::raw::c_int, + iEnd: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_fts5_tokenizer() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(fts5_tokenizer)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(fts5_tokenizer)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xTokenize) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct fts5_api { + pub iVersion: ::std::os::raw::c_int, + pub xCreateTokenizer: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + pContext: *mut ::std::os::raw::c_void, + pTokenizer: *mut fts5_tokenizer, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub xFindTokenizer: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + ppContext: *mut *mut ::std::os::raw::c_void, + pTokenizer: *mut fts5_tokenizer, + ) -> ::std::os::raw::c_int, + >, + pub xCreateFunction: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + pContext: *mut ::std::os::raw::c_void, + xFunction: fts5_extension_function, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_fts5_api() { + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(fts5_api)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(fts5_api)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreateTokenizer as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xCreateTokenizer) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindTokenizer as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xFindTokenizer) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreateFunction as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xCreateFunction) + ) + ); +} +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.26.0-ext-embed.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.26.0-ext-embed.rs new file mode 100644 index 000000000..a8c5a04cd --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.26.0-ext-embed.rs @@ -0,0 +1,11140 @@ +/* automatically generated by rust-bindgen */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.26.0\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3026000; +pub const SQLITE_SOURCE_ID: &'static [u8; 85usize] = + b"2018-12-01 12:34:55 bf8c1b2b7a5960c282e543b9c293686dccff272512d08865f4600fb58238b4f9\0"; +pub const SQLITE_OK: i32 = 0; +pub const SQLITE_ERROR: i32 = 1; +pub const SQLITE_INTERNAL: i32 = 2; +pub const SQLITE_PERM: i32 = 3; +pub const SQLITE_ABORT: i32 = 4; +pub const SQLITE_BUSY: i32 = 5; +pub const SQLITE_LOCKED: i32 = 6; +pub const SQLITE_NOMEM: i32 = 7; +pub const SQLITE_READONLY: i32 = 8; +pub const SQLITE_INTERRUPT: i32 = 9; +pub const SQLITE_IOERR: i32 = 10; +pub const SQLITE_CORRUPT: i32 = 11; +pub const SQLITE_NOTFOUND: i32 = 12; +pub const SQLITE_FULL: i32 = 13; +pub const SQLITE_CANTOPEN: i32 = 14; +pub const SQLITE_PROTOCOL: i32 = 15; +pub const SQLITE_EMPTY: i32 = 16; +pub const SQLITE_SCHEMA: i32 = 17; +pub const SQLITE_TOOBIG: i32 = 18; +pub const SQLITE_CONSTRAINT: i32 = 19; +pub const SQLITE_MISMATCH: i32 = 20; +pub const SQLITE_MISUSE: i32 = 21; +pub const SQLITE_NOLFS: i32 = 22; +pub const SQLITE_AUTH: i32 = 23; +pub const SQLITE_FORMAT: i32 = 24; +pub const SQLITE_RANGE: i32 = 25; +pub const SQLITE_NOTADB: i32 = 26; +pub const SQLITE_NOTICE: i32 = 27; +pub const SQLITE_WARNING: i32 = 28; +pub const SQLITE_ROW: i32 = 100; +pub const SQLITE_DONE: i32 = 101; +pub const SQLITE_ERROR_MISSING_COLLSEQ: i32 = 257; +pub const SQLITE_ERROR_RETRY: i32 = 513; +pub const SQLITE_ERROR_SNAPSHOT: i32 = 769; +pub const SQLITE_IOERR_READ: i32 = 266; +pub const SQLITE_IOERR_SHORT_READ: i32 = 522; +pub const SQLITE_IOERR_WRITE: i32 = 778; +pub const SQLITE_IOERR_FSYNC: i32 = 1034; +pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; +pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; +pub const SQLITE_IOERR_FSTAT: i32 = 1802; +pub const SQLITE_IOERR_UNLOCK: i32 = 2058; +pub const SQLITE_IOERR_RDLOCK: i32 = 2314; +pub const SQLITE_IOERR_DELETE: i32 = 2570; +pub const SQLITE_IOERR_BLOCKED: i32 = 2826; +pub const SQLITE_IOERR_NOMEM: i32 = 3082; +pub const SQLITE_IOERR_ACCESS: i32 = 3338; +pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; +pub const SQLITE_IOERR_LOCK: i32 = 3850; +pub const SQLITE_IOERR_CLOSE: i32 = 4106; +pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; +pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; +pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; +pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; +pub const SQLITE_IOERR_SHMMAP: i32 = 5386; +pub const SQLITE_IOERR_SEEK: i32 = 5642; +pub const SQLITE_IOERR_DELETE_NOENT: i32 = 5898; +pub const SQLITE_IOERR_MMAP: i32 = 6154; +pub const SQLITE_IOERR_GETTEMPPATH: i32 = 6410; +pub const SQLITE_IOERR_CONVPATH: i32 = 6666; +pub const SQLITE_IOERR_VNODE: i32 = 6922; +pub const SQLITE_IOERR_AUTH: i32 = 7178; +pub const SQLITE_IOERR_BEGIN_ATOMIC: i32 = 7434; +pub const SQLITE_IOERR_COMMIT_ATOMIC: i32 = 7690; +pub const SQLITE_IOERR_ROLLBACK_ATOMIC: i32 = 7946; +pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; +pub const SQLITE_LOCKED_VTAB: i32 = 518; +pub const SQLITE_BUSY_RECOVERY: i32 = 261; +pub const SQLITE_BUSY_SNAPSHOT: i32 = 517; +pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; +pub const SQLITE_CANTOPEN_ISDIR: i32 = 526; +pub const SQLITE_CANTOPEN_FULLPATH: i32 = 782; +pub const SQLITE_CANTOPEN_CONVPATH: i32 = 1038; +pub const SQLITE_CANTOPEN_DIRTYWAL: i32 = 1294; +pub const SQLITE_CORRUPT_VTAB: i32 = 267; +pub const SQLITE_CORRUPT_SEQUENCE: i32 = 523; +pub const SQLITE_READONLY_RECOVERY: i32 = 264; +pub const SQLITE_READONLY_CANTLOCK: i32 = 520; +pub const SQLITE_READONLY_ROLLBACK: i32 = 776; +pub const SQLITE_READONLY_DBMOVED: i32 = 1032; +pub const SQLITE_READONLY_CANTINIT: i32 = 1288; +pub const SQLITE_READONLY_DIRECTORY: i32 = 1544; +pub const SQLITE_ABORT_ROLLBACK: i32 = 516; +pub const SQLITE_CONSTRAINT_CHECK: i32 = 275; +pub const SQLITE_CONSTRAINT_COMMITHOOK: i32 = 531; +pub const SQLITE_CONSTRAINT_FOREIGNKEY: i32 = 787; +pub const SQLITE_CONSTRAINT_FUNCTION: i32 = 1043; +pub const SQLITE_CONSTRAINT_NOTNULL: i32 = 1299; +pub const SQLITE_CONSTRAINT_PRIMARYKEY: i32 = 1555; +pub const SQLITE_CONSTRAINT_TRIGGER: i32 = 1811; +pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067; +pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323; +pub const SQLITE_CONSTRAINT_ROWID: i32 = 2579; +pub const SQLITE_NOTICE_RECOVER_WAL: i32 = 283; +pub const SQLITE_NOTICE_RECOVER_ROLLBACK: i32 = 539; +pub const SQLITE_WARNING_AUTOINDEX: i32 = 284; +pub const SQLITE_AUTH_USER: i32 = 279; +pub const SQLITE_OK_LOAD_PERMANENTLY: i32 = 256; +pub const SQLITE_OPEN_READONLY: i32 = 1; +pub const SQLITE_OPEN_READWRITE: i32 = 2; +pub const SQLITE_OPEN_CREATE: i32 = 4; +pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; +pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; +pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; +pub const SQLITE_OPEN_URI: i32 = 64; +pub const SQLITE_OPEN_MEMORY: i32 = 128; +pub const SQLITE_OPEN_MAIN_DB: i32 = 256; +pub const SQLITE_OPEN_TEMP_DB: i32 = 512; +pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; +pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; +pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; +pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; +pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; +pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; +pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; +pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; +pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; +pub const SQLITE_OPEN_WAL: i32 = 524288; +pub const SQLITE_IOCAP_ATOMIC: i32 = 1; +pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; +pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; +pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; +pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; +pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; +pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; +pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; +pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; +pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; +pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; +pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; +pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE: i32 = 4096; +pub const SQLITE_IOCAP_IMMUTABLE: i32 = 8192; +pub const SQLITE_IOCAP_BATCH_ATOMIC: i32 = 16384; +pub const SQLITE_LOCK_NONE: i32 = 0; +pub const SQLITE_LOCK_SHARED: i32 = 1; +pub const SQLITE_LOCK_RESERVED: i32 = 2; +pub const SQLITE_LOCK_PENDING: i32 = 3; +pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; +pub const SQLITE_SYNC_NORMAL: i32 = 2; +pub const SQLITE_SYNC_FULL: i32 = 3; +pub const SQLITE_SYNC_DATAONLY: i32 = 16; +pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; +pub const SQLITE_FCNTL_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_FCNTL_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_FCNTL_LAST_ERRNO: i32 = 4; +pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; +pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; +pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; +pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; +pub const SQLITE_FCNTL_WIN32_AV_RETRY: i32 = 9; +pub const SQLITE_FCNTL_PERSIST_WAL: i32 = 10; +pub const SQLITE_FCNTL_OVERWRITE: i32 = 11; +pub const SQLITE_FCNTL_VFSNAME: i32 = 12; +pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE: i32 = 13; +pub const SQLITE_FCNTL_PRAGMA: i32 = 14; +pub const SQLITE_FCNTL_BUSYHANDLER: i32 = 15; +pub const SQLITE_FCNTL_TEMPFILENAME: i32 = 16; +pub const SQLITE_FCNTL_MMAP_SIZE: i32 = 18; +pub const SQLITE_FCNTL_TRACE: i32 = 19; +pub const SQLITE_FCNTL_HAS_MOVED: i32 = 20; +pub const SQLITE_FCNTL_SYNC: i32 = 21; +pub const SQLITE_FCNTL_COMMIT_PHASETWO: i32 = 22; +pub const SQLITE_FCNTL_WIN32_SET_HANDLE: i32 = 23; +pub const SQLITE_FCNTL_WAL_BLOCK: i32 = 24; +pub const SQLITE_FCNTL_ZIPVFS: i32 = 25; +pub const SQLITE_FCNTL_RBU: i32 = 26; +pub const SQLITE_FCNTL_VFS_POINTER: i32 = 27; +pub const SQLITE_FCNTL_JOURNAL_POINTER: i32 = 28; +pub const SQLITE_FCNTL_WIN32_GET_HANDLE: i32 = 29; +pub const SQLITE_FCNTL_PDB: i32 = 30; +pub const SQLITE_FCNTL_BEGIN_ATOMIC_WRITE: i32 = 31; +pub const SQLITE_FCNTL_COMMIT_ATOMIC_WRITE: i32 = 32; +pub const SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE: i32 = 33; +pub const SQLITE_FCNTL_LOCK_TIMEOUT: i32 = 34; +pub const SQLITE_FCNTL_DATA_VERSION: i32 = 35; +pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_LAST_ERRNO: i32 = 4; +pub const SQLITE_ACCESS_EXISTS: i32 = 0; +pub const SQLITE_ACCESS_READWRITE: i32 = 1; +pub const SQLITE_ACCESS_READ: i32 = 2; +pub const SQLITE_SHM_UNLOCK: i32 = 1; +pub const SQLITE_SHM_LOCK: i32 = 2; +pub const SQLITE_SHM_SHARED: i32 = 4; +pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; +pub const SQLITE_SHM_NLOCK: i32 = 8; +pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; +pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; +pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; +pub const SQLITE_CONFIG_MALLOC: i32 = 4; +pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; +pub const SQLITE_CONFIG_SCRATCH: i32 = 6; +pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; +pub const SQLITE_CONFIG_HEAP: i32 = 8; +pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; +pub const SQLITE_CONFIG_MUTEX: i32 = 10; +pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; +pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; +pub const SQLITE_CONFIG_PCACHE: i32 = 14; +pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; +pub const SQLITE_CONFIG_LOG: i32 = 16; +pub const SQLITE_CONFIG_URI: i32 = 17; +pub const SQLITE_CONFIG_PCACHE2: i32 = 18; +pub const SQLITE_CONFIG_GETPCACHE2: i32 = 19; +pub const SQLITE_CONFIG_COVERING_INDEX_SCAN: i32 = 20; +pub const SQLITE_CONFIG_SQLLOG: i32 = 21; +pub const SQLITE_CONFIG_MMAP_SIZE: i32 = 22; +pub const SQLITE_CONFIG_WIN32_HEAPSIZE: i32 = 23; +pub const SQLITE_CONFIG_PCACHE_HDRSZ: i32 = 24; +pub const SQLITE_CONFIG_PMASZ: i32 = 25; +pub const SQLITE_CONFIG_STMTJRNL_SPILL: i32 = 26; +pub const SQLITE_CONFIG_SMALL_MALLOC: i32 = 27; +pub const SQLITE_CONFIG_SORTERREF_SIZE: i32 = 28; +pub const SQLITE_DBCONFIG_MAINDBNAME: i32 = 1000; +pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; +pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; +pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; +pub const SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: i32 = 1004; +pub const SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: i32 = 1005; +pub const SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE: i32 = 1006; +pub const SQLITE_DBCONFIG_ENABLE_QPSG: i32 = 1007; +pub const SQLITE_DBCONFIG_TRIGGER_EQP: i32 = 1008; +pub const SQLITE_DBCONFIG_RESET_DATABASE: i32 = 1009; +pub const SQLITE_DBCONFIG_DEFENSIVE: i32 = 1010; +pub const SQLITE_DBCONFIG_MAX: i32 = 1010; +pub const SQLITE_DENY: i32 = 1; +pub const SQLITE_IGNORE: i32 = 2; +pub const SQLITE_CREATE_INDEX: i32 = 1; +pub const SQLITE_CREATE_TABLE: i32 = 2; +pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; +pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; +pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; +pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; +pub const SQLITE_CREATE_TRIGGER: i32 = 7; +pub const SQLITE_CREATE_VIEW: i32 = 8; +pub const SQLITE_DELETE: i32 = 9; +pub const SQLITE_DROP_INDEX: i32 = 10; +pub const SQLITE_DROP_TABLE: i32 = 11; +pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; +pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; +pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; +pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; +pub const SQLITE_DROP_TRIGGER: i32 = 16; +pub const SQLITE_DROP_VIEW: i32 = 17; +pub const SQLITE_INSERT: i32 = 18; +pub const SQLITE_PRAGMA: i32 = 19; +pub const SQLITE_READ: i32 = 20; +pub const SQLITE_SELECT: i32 = 21; +pub const SQLITE_TRANSACTION: i32 = 22; +pub const SQLITE_UPDATE: i32 = 23; +pub const SQLITE_ATTACH: i32 = 24; +pub const SQLITE_DETACH: i32 = 25; +pub const SQLITE_ALTER_TABLE: i32 = 26; +pub const SQLITE_REINDEX: i32 = 27; +pub const SQLITE_ANALYZE: i32 = 28; +pub const SQLITE_CREATE_VTABLE: i32 = 29; +pub const SQLITE_DROP_VTABLE: i32 = 30; +pub const SQLITE_FUNCTION: i32 = 31; +pub const SQLITE_SAVEPOINT: i32 = 32; +pub const SQLITE_COPY: i32 = 0; +pub const SQLITE_RECURSIVE: i32 = 33; +pub const SQLITE_TRACE_STMT: i32 = 1; +pub const SQLITE_TRACE_PROFILE: i32 = 2; +pub const SQLITE_TRACE_ROW: i32 = 4; +pub const SQLITE_TRACE_CLOSE: i32 = 8; +pub const SQLITE_LIMIT_LENGTH: i32 = 0; +pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; +pub const SQLITE_LIMIT_COLUMN: i32 = 2; +pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; +pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; +pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; +pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; +pub const SQLITE_LIMIT_ATTACHED: i32 = 7; +pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; +pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; +pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; +pub const SQLITE_LIMIT_WORKER_THREADS: i32 = 11; +pub const SQLITE_PREPARE_PERSISTENT: i32 = 1; +pub const SQLITE_PREPARE_NORMALIZE: i32 = 2; +pub const SQLITE_INTEGER: i32 = 1; +pub const SQLITE_FLOAT: i32 = 2; +pub const SQLITE_BLOB: i32 = 4; +pub const SQLITE_NULL: i32 = 5; +pub const SQLITE_TEXT: i32 = 3; +pub const SQLITE3_TEXT: i32 = 3; +pub const SQLITE_UTF8: i32 = 1; +pub const SQLITE_UTF16LE: i32 = 2; +pub const SQLITE_UTF16BE: i32 = 3; +pub const SQLITE_UTF16: i32 = 4; +pub const SQLITE_ANY: i32 = 5; +pub const SQLITE_UTF16_ALIGNED: i32 = 8; +pub const SQLITE_DETERMINISTIC: i32 = 2048; +pub const SQLITE_WIN32_DATA_DIRECTORY_TYPE: i32 = 1; +pub const SQLITE_WIN32_TEMP_DIRECTORY_TYPE: i32 = 2; +pub const SQLITE_INDEX_SCAN_UNIQUE: i32 = 1; +pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; +pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; +pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; +pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; +pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; +pub const SQLITE_INDEX_CONSTRAINT_LIKE: i32 = 65; +pub const SQLITE_INDEX_CONSTRAINT_GLOB: i32 = 66; +pub const SQLITE_INDEX_CONSTRAINT_REGEXP: i32 = 67; +pub const SQLITE_INDEX_CONSTRAINT_NE: i32 = 68; +pub const SQLITE_INDEX_CONSTRAINT_ISNOT: i32 = 69; +pub const SQLITE_INDEX_CONSTRAINT_ISNOTNULL: i32 = 70; +pub const SQLITE_INDEX_CONSTRAINT_ISNULL: i32 = 71; +pub const SQLITE_INDEX_CONSTRAINT_IS: i32 = 72; +pub const SQLITE_INDEX_CONSTRAINT_FUNCTION: i32 = 150; +pub const SQLITE_MUTEX_FAST: i32 = 0; +pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; +pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; +pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; +pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; +pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; +pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; +pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; +pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; +pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; +pub const SQLITE_MUTEX_STATIC_APP1: i32 = 8; +pub const SQLITE_MUTEX_STATIC_APP2: i32 = 9; +pub const SQLITE_MUTEX_STATIC_APP3: i32 = 10; +pub const SQLITE_MUTEX_STATIC_VFS1: i32 = 11; +pub const SQLITE_MUTEX_STATIC_VFS2: i32 = 12; +pub const SQLITE_MUTEX_STATIC_VFS3: i32 = 13; +pub const SQLITE_TESTCTRL_FIRST: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; +pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; +pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; +pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; +pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; +pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; +pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; +pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; +pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; +pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; +pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; +pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 17; +pub const SQLITE_TESTCTRL_INTERNAL_FUNCTIONS: i32 = 17; +pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 18; +pub const SQLITE_TESTCTRL_EXPLAIN_STMT: i32 = 19; +pub const SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD: i32 = 19; +pub const SQLITE_TESTCTRL_NEVER_CORRUPT: i32 = 20; +pub const SQLITE_TESTCTRL_VDBE_COVERAGE: i32 = 21; +pub const SQLITE_TESTCTRL_BYTEORDER: i32 = 22; +pub const SQLITE_TESTCTRL_ISINIT: i32 = 23; +pub const SQLITE_TESTCTRL_SORTER_MMAP: i32 = 24; +pub const SQLITE_TESTCTRL_IMPOSTER: i32 = 25; +pub const SQLITE_TESTCTRL_PARSER_COVERAGE: i32 = 26; +pub const SQLITE_TESTCTRL_LAST: i32 = 26; +pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; +pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; +pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; +pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; +pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; +pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; +pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; +pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; +pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; +pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; +pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; +pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; +pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; +pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; +pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; +pub const SQLITE_DBSTATUS_CACHE_HIT: i32 = 7; +pub const SQLITE_DBSTATUS_CACHE_MISS: i32 = 8; +pub const SQLITE_DBSTATUS_CACHE_WRITE: i32 = 9; +pub const SQLITE_DBSTATUS_DEFERRED_FKS: i32 = 10; +pub const SQLITE_DBSTATUS_CACHE_USED_SHARED: i32 = 11; +pub const SQLITE_DBSTATUS_CACHE_SPILL: i32 = 12; +pub const SQLITE_DBSTATUS_MAX: i32 = 12; +pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; +pub const SQLITE_STMTSTATUS_SORT: i32 = 2; +pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; +pub const SQLITE_STMTSTATUS_VM_STEP: i32 = 4; +pub const SQLITE_STMTSTATUS_REPREPARE: i32 = 5; +pub const SQLITE_STMTSTATUS_RUN: i32 = 6; +pub const SQLITE_STMTSTATUS_MEMUSED: i32 = 99; +pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; +pub const SQLITE_CHECKPOINT_FULL: i32 = 1; +pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; +pub const SQLITE_CHECKPOINT_TRUNCATE: i32 = 3; +pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; +pub const SQLITE_ROLLBACK: i32 = 1; +pub const SQLITE_FAIL: i32 = 3; +pub const SQLITE_REPLACE: i32 = 5; +pub const SQLITE_SCANSTAT_NLOOP: i32 = 0; +pub const SQLITE_SCANSTAT_NVISIT: i32 = 1; +pub const SQLITE_SCANSTAT_EST: i32 = 2; +pub const SQLITE_SCANSTAT_NAME: i32 = 3; +pub const SQLITE_SCANSTAT_EXPLAIN: i32 = 4; +pub const SQLITE_SCANSTAT_SELECTID: i32 = 5; +pub const SQLITE_SERIALIZE_NOCOPY: i32 = 1; +pub const SQLITE_DESERIALIZE_FREEONCLOSE: i32 = 1; +pub const SQLITE_DESERIALIZE_RESIZEABLE: i32 = 2; +pub const SQLITE_DESERIALIZE_READONLY: i32 = 4; +pub const NOT_WITHIN: i32 = 0; +pub const PARTLY_WITHIN: i32 = 1; +pub const FULLY_WITHIN: i32 = 2; +pub const FTS5_TOKENIZE_QUERY: i32 = 1; +pub const FTS5_TOKENIZE_PREFIX: i32 = 2; +pub const FTS5_TOKENIZE_DOCUMENT: i32 = 4; +pub const FTS5_TOKENIZE_AUX: i32 = 8; +pub const FTS5_TOKEN_COLOCATED: i32 = 1; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; +extern "C" { + #[link_name = "\u{1}sqlite3_version"] + pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3 { + _unused: [u8; 0], +} +pub type sqlite_int64 = ::std::os::raw::c_longlong; +pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; +pub type sqlite3_int64 = sqlite_int64; +pub type sqlite3_uint64 = sqlite_uint64; +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_file { + pub pMethods: *const sqlite3_io_methods, +} +#[test] +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xShmMap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iPg: ::std::os::raw::c_int, + pgsz: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xShmLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + offset: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xShmBarrier: ::std::option::Option, + pub xShmUnmap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + deleteFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iOfst: sqlite3_int64, + iAmt: ::std::os::raw::c_int, + pp: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xUnfetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iOfst: sqlite3_int64, + p: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 152usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmMap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmBarrier) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmUnmap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnfetch as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnfetch) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +pub type sqlite3_syscall_ptr = ::std::option::Option; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vfs { + pub iVersion: ::std::os::raw::c_int, + pub szOsFile: ::std::os::raw::c_int, + pub mxPathname: ::std::os::raw::c_int, + pub pNext: *mut sqlite3_vfs, + pub zName: *const ::std::os::raw::c_char, + pub pAppData: *mut ::std::os::raw::c_void, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTimeInt64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xSetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: sqlite3_syscall_ptr, + ) -> ::std::os::raw::c_int, + >, + pub xGetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> sqlite3_syscall_ptr, + >, + pub xNextSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_vfs() { + assert_eq!( + ::std::mem::size_of::(), + 168usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTimeInt64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xNextSystemCall) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mem_methods { + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub pAppData: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_mem_methods() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_stmt { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_value { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_context { + _unused: [u8; 0], +} +pub type sqlite3_destructor_type = + ::std::option::Option; +extern "C" { + #[link_name = "\u{1}sqlite3_temp_directory"] + pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "\u{1}sqlite3_data_directory"] + pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSavepoint: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRelease: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRollbackTo: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xShadowName: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 192usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSavepoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRelease) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollbackTo) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShadowName as *const _ as usize }, + 184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xShadowName) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info { + pub nConstraint: ::std::os::raw::c_int, + pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, + pub nOrderBy: ::std::os::raw::c_int, + pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, + pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, + pub idxNum: ::std::os::raw::c_int, + pub idxStr: *mut ::std::os::raw::c_char, + pub needToFreeIdxStr: ::std::os::raw::c_int, + pub orderByConsumed: ::std::os::raw::c_int, + pub estimatedCost: f64, + pub estimatedRows: sqlite3_int64, + pub idxFlags: ::std::os::raw::c_int, + pub colUsed: sqlite3_uint64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint { + pub iColumn: ::std::os::raw::c_int, + pub op: ::std::os::raw::c_uchar, + pub usable: ::std::os::raw::c_uchar, + pub iTermOffset: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_orderby { + pub iColumn: ::std::os::raw::c_int, + pub desc: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint_usage { + pub argvIndex: ::std::os::raw::c_int, + pub omit: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); +} +#[test] +fn bindgen_test_layout_sqlite3_index_info() { + assert_eq!( + ::std::mem::size_of::(), + 96usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedRows as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedRows) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxFlags as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxFlags) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).colUsed as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(colUsed) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_blob { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex_methods { + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_mutex_methods() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_str { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_page { + pub pBuf: *mut ::std::os::raw::c_void, + pub pExtra: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_page() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pBuf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pExtra) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods2 { + pub iVersion: ::std::os::raw::c_int, + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + szExtra: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache_page, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, + pub xShrink: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods2() { + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iVersion as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDestroy as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShrink) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods { + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_backup { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct sqlite3_snapshot { + pub hidden: [::std::os::raw::c_uchar; 48usize], +} +#[test] +fn bindgen_test_layout_sqlite3_snapshot() { + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!("Size of: ", stringify!(sqlite3_snapshot)) + ); + assert_eq!( + ::std::mem::align_of::(), + 1usize, + concat!("Alignment of ", stringify!(sqlite3_snapshot)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).hidden as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_snapshot), + "::", + stringify!(hidden) + ) + ); +} +pub type sqlite3_rtree_dbl = f64; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_geometry { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut sqlite3_rtree_dbl, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_geometry() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(xDelUser) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_query_info { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut sqlite3_rtree_dbl, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, + pub aCoord: *mut sqlite3_rtree_dbl, + pub anQueue: *mut ::std::os::raw::c_uint, + pub nCoord: ::std::os::raw::c_int, + pub iLevel: ::std::os::raw::c_int, + pub mxLevel: ::std::os::raw::c_int, + pub iRowid: sqlite3_int64, + pub rParentScore: sqlite3_rtree_dbl, + pub eParentWithin: ::std::os::raw::c_int, + pub eWithin: ::std::os::raw::c_int, + pub rScore: sqlite3_rtree_dbl, + pub apSqlParam: *mut *mut sqlite3_value, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_query_info() { + assert_eq!( + ::std::mem::size_of::(), + 112usize, + concat!("Size of: ", stringify!(sqlite3_rtree_query_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_query_info)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).pContext as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDelUser as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(xDelUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aCoord as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(aCoord) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).anQueue as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(anQueue) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nCoord as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(nCoord) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iLevel as *const _ as usize }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(iLevel) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mxLevel as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(mxLevel) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iRowid as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(iRowid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rParentScore as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(rParentScore) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eParentWithin as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(eParentWithin) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eWithin as *const _ as usize + }, + 92usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(eWithin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).rScore as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(rScore) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).apSqlParam as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(apSqlParam) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5Context { + _unused: [u8; 0], +} +pub type fts5_extension_function = ::std::option::Option< + unsafe extern "C" fn( + pApi: *const Fts5ExtensionApi, + pFts: *mut Fts5Context, + pCtx: *mut sqlite3_context, + nVal: ::std::os::raw::c_int, + apVal: *mut *mut sqlite3_value, + ), +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5PhraseIter { + pub a: *const ::std::os::raw::c_uchar, + pub b: *const ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_Fts5PhraseIter() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Fts5PhraseIter)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Fts5PhraseIter)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).a as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Fts5PhraseIter), + "::", + stringify!(a) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).b as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Fts5PhraseIter), + "::", + stringify!(b) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5ExtensionApi { + pub iVersion: ::std::os::raw::c_int, + pub xUserData: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> *mut ::std::os::raw::c_void, + >, + pub xColumnCount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, + >, + pub xRowCount: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pnRow: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xColumnTotalSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pnToken: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTokenize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pText: *const ::std::os::raw::c_char, + nText: ::std::os::raw::c_int, + pCtx: *mut ::std::os::raw::c_void, + xToken: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + arg6: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseCount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, + >, + pub xPhraseSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xInstCount: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pnInst: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xInst: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iIdx: ::std::os::raw::c_int, + piPhrase: *mut ::std::os::raw::c_int, + piCol: *mut ::std::os::raw::c_int, + piOff: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: + ::std::option::Option sqlite3_int64>, + pub xColumnText: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pz: *mut *const ::std::os::raw::c_char, + pn: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xColumnSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pnToken: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xQueryPhrase: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + pUserData: *mut ::std::os::raw::c_void, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const Fts5ExtensionApi, + arg2: *mut Fts5Context, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub xSetAuxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pAux: *mut ::std::os::raw::c_void, + xDelete: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub xGetAuxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + bClear: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xPhraseFirst: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + arg2: *mut Fts5PhraseIter, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseNext: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + arg2: *mut Fts5PhraseIter, + piCol: *mut ::std::os::raw::c_int, + piOff: *mut ::std::os::raw::c_int, + ), + >, + pub xPhraseFirstColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + arg2: *mut Fts5PhraseIter, + arg3: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseNextColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + arg2: *mut Fts5PhraseIter, + piCol: *mut ::std::os::raw::c_int, + ), + >, +} +#[test] +fn bindgen_test_layout_Fts5ExtensionApi() { + assert_eq!( + ::std::mem::size_of::(), + 160usize, + concat!("Size of: ", stringify!(Fts5ExtensionApi)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Fts5ExtensionApi)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUserData as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xUserData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnCount as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowCount as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xRowCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xColumnTotalSize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnTotalSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xTokenize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseCount as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseSize as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInstCount as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xInstCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInst as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xInst) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnText as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnText) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnSize as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xQueryPhrase as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xQueryPhrase) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetAuxdata as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xSetAuxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetAuxdata as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xGetAuxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseFirst as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseFirst) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseNext as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseNext) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPhraseFirstColumn as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseFirstColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPhraseNextColumn as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseNextColumn) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5Tokenizer { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct fts5_tokenizer { + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + azArg: *mut *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ppOut: *mut *mut Fts5Tokenizer, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option, + pub xTokenize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Tokenizer, + pCtx: *mut ::std::os::raw::c_void, + flags: ::std::os::raw::c_int, + pText: *const ::std::os::raw::c_char, + nText: ::std::os::raw::c_int, + xToken: ::std::option::Option< + unsafe extern "C" fn( + pCtx: *mut ::std::os::raw::c_void, + tflags: ::std::os::raw::c_int, + pToken: *const ::std::os::raw::c_char, + nToken: ::std::os::raw::c_int, + iStart: ::std::os::raw::c_int, + iEnd: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_fts5_tokenizer() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(fts5_tokenizer)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(fts5_tokenizer)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xTokenize) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct fts5_api { + pub iVersion: ::std::os::raw::c_int, + pub xCreateTokenizer: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + pContext: *mut ::std::os::raw::c_void, + pTokenizer: *mut fts5_tokenizer, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub xFindTokenizer: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + ppContext: *mut *mut ::std::os::raw::c_void, + pTokenizer: *mut fts5_tokenizer, + ) -> ::std::os::raw::c_int, + >, + pub xCreateFunction: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + pContext: *mut ::std::os::raw::c_void, + xFunction: fts5_extension_function, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_fts5_api() { + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(fts5_api)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(fts5_api)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreateTokenizer as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xCreateTokenizer) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindTokenizer as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xFindTokenizer) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreateFunction as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xCreateFunction) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_api_routines { + pub aggregate_context: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub aggregate_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, + >, + pub bind_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_double: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int, + >, + pub bind_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, + ) -> ::std::os::raw::c_int, + >, + pub bind_null: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub bind_parameter_index: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub bind_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub busy_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub busy_timeout: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub changes: + ::std::option::Option ::std::os::raw::c_int>, + pub close: + ::std::option::Option ::std::os::raw::c_int>, + pub collation_needed: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub collation_needed16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub column_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_bytes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_bytes16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub column_database_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_database_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_decltype: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_decltype16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_double: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, + >, + pub column_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_int64: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, + >, + pub column_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_origin_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_origin_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_table_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_table_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar, + >, + pub column_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_type: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value, + >, + pub commit_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub complete: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub complete16: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub create_collation: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_collation16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_function16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_module: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub data_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub db_handle: + ::std::option::Option *mut sqlite3>, + pub declare_vtab: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub enable_shared_cache: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub errmsg: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, + >, + pub errmsg16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, + >, + pub exec: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub expired: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub finalize: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub free: ::std::option::Option, + pub free_table: + ::std::option::Option, + pub get_autocommit: + ::std::option::Option ::std::os::raw::c_int>, + pub get_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub get_table: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub global_recover: ::std::option::Option ::std::os::raw::c_int>, + pub interruptx: ::std::option::Option, + pub last_insert_rowid: + ::std::option::Option sqlite_int64>, + pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, + pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, + pub malloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub mprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub open16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub prepare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub profile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub progress_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ), + >, + pub realloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub result_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_double: + ::std::option::Option, + pub result_error: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_error16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_int64: + ::std::option::Option, + pub result_null: ::std::option::Option, + pub result_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16be: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16le: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_value: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), + >, + pub rollback_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub set_authorizer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub set_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, + ), + >, + pub xsnprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub step: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub table_column_metadata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub thread_cleanup: ::std::option::Option, + pub total_changes: + ::std::option::Option ::std::os::raw::c_int>, + pub trace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub transfer_bindings: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int, + >, + pub update_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub user_data: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, + >, + pub value_blob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_bytes16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_double: ::std::option::Option f64>, + pub value_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_int64: + ::std::option::Option sqlite_int64>, + pub value_numeric_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_text: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, + >, + pub value_text16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16be: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16le: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub vmprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub overload_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub prepare_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub clear_bindings: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub create_module_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_close: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int, + >, + pub blob_read: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_write: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub create_collation_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub file_control: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub memory_highwater: + ::std::option::Option sqlite3_int64>, + pub memory_used: ::std::option::Option sqlite3_int64>, + pub mutex_alloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub mutex_enter: ::std::option::Option, + pub mutex_free: ::std::option::Option, + pub mutex_leave: ::std::option::Option, + pub mutex_try: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub open_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub release_memory: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub result_error_nomem: ::std::option::Option, + pub result_error_toobig: + ::std::option::Option, + pub sleep: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub soft_heap_limit: ::std::option::Option, + pub vfs_find: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, + >, + pub vfs_register: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub vfs_unregister: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, + >, + pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, + pub result_zeroblob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_error_code: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub test_control: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, + >, + pub randomness: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), + >, + pub context_db_handle: + ::std::option::Option *mut sqlite3>, + pub extended_result_codes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub limit: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub next_stmt: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, + >, + pub sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, + >, + pub status: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub backup_finish: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_init: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, + ) -> *mut sqlite3_backup, + >, + pub backup_pagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_remaining: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_step: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub compileoption_get: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, + >, + pub compileoption_used: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub create_function_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub db_config: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int, + >, + pub db_mutex: + ::std::option::Option *mut sqlite3_mutex>, + pub db_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub extended_errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub log: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char, ...), + >, + pub soft_heap_limit64: + ::std::option::Option sqlite3_int64>, + pub sourceid: ::std::option::Option *const ::std::os::raw::c_char>, + pub stmt_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub strnicmp: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub unlock_notify: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub wal_autocheckpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub wal_checkpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub wal_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub blob_reopen: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob, arg2: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub vtab_config: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int, + >, + pub vtab_on_conflict: + ::std::option::Option ::std::os::raw::c_int>, + pub close_v2: + ::std::option::Option ::std::os::raw::c_int>, + pub db_filename: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, + pub db_readonly: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub db_release_memory: + ::std::option::Option ::std::os::raw::c_int>, + pub errstr: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, + >, + pub stmt_busy: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub stmt_readonly: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub stricmp: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub uri_boolean: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub uri_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64, + ) -> sqlite3_int64, + >, + pub uri_parameter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, + pub xvsnprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub wal_checkpoint_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub auto_extension: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_blob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + arg6: ::std::os::raw::c_uchar, + ) -> ::std::os::raw::c_int, + >, + pub cancel_auto_extension: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub load_extension: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub malloc64: ::std::option::Option< + unsafe extern "C" fn(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void, + >, + pub msize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64, + >, + pub realloc64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_uint64, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset_auto_extension: ::std::option::Option, + pub result_blob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + ), + >, + pub result_text64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + arg5: ::std::os::raw::c_uchar, + ), + >, + pub strglob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub value_dup: ::std::option::Option< + unsafe extern "C" fn(arg1: *const sqlite3_value) -> *mut sqlite3_value, + >, + pub value_free: ::std::option::Option, + pub result_zeroblob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: sqlite3_uint64, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_uint64, + ) -> ::std::os::raw::c_int, + >, + pub value_subtype: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint, + >, + pub result_subtype: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint), + >, + pub status64: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut sqlite3_int64, + arg3: *mut sqlite3_int64, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub strlike: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_uint, + ) -> ::std::os::raw::c_int, + >, + pub db_cacheflush: + ::std::option::Option ::std::os::raw::c_int>, + pub system_errno: + ::std::option::Option ::std::os::raw::c_int>, + pub trace_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_uint, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_uint, + arg2: *mut ::std::os::raw::c_void, + arg3: *mut ::std::os::raw::c_void, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub expanded_sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char, + >, + pub set_last_insert_rowid: + ::std::option::Option, + pub prepare_v3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_uint, + arg5: *mut *mut sqlite3_stmt, + arg6: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16_v3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_uint, + arg5: *mut *mut sqlite3_stmt, + arg6: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub bind_pointer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: *const ::std::os::raw::c_char, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub result_pointer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *mut ::std::os::raw::c_void, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::option::Option, + ), + >, + pub value_pointer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_value, + arg2: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub vtab_nochange: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, + >, + pub value_nochange: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub vtab_collation: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_index_info, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub keyword_count: ::std::option::Option ::std::os::raw::c_int>, + pub keyword_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut *const ::std::os::raw::c_char, + arg3: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub keyword_check: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub str_new: + ::std::option::Option *mut sqlite3_str>, + pub str_finish: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char, + >, + pub str_appendf: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_str, zFormat: *const ::std::os::raw::c_char, ...), + >, + pub str_vappendf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_str, + zFormat: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ), + >, + pub str_append: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_str, + zIn: *const ::std::os::raw::c_char, + N: ::std::os::raw::c_int, + ), + >, + pub str_appendall: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_str, zIn: *const ::std::os::raw::c_char), + >, + pub str_appendchar: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_str, + N: ::std::os::raw::c_int, + C: ::std::os::raw::c_char, + ), + >, + pub str_reset: ::std::option::Option, + pub str_errcode: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int, + >, + pub str_length: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int, + >, + pub str_value: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char, + >, + pub create_window_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xValue: ::std::option::Option, + xInv: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub normalized_sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_api_routines() { + assert_eq!( + ::std::mem::size_of::(), + 1928usize, + concat!("Size of: ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_context as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_context) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_count as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_double as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_count as *const _ + as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_index as *const _ + as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_index) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_name as *const _ + as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text16 as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_handler as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_handler) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_timeout as *const _ as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_timeout) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed as *const _ as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_blob as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes as *const _ as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize + }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_count as *const _ as usize + }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name as *const _ + as usize + }, + 184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name16 as *const _ + as usize + }, + 192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype as *const _ as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize + }, + 208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_double as *const _ as usize + }, + 216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, + 224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_int64 as *const _ as usize + }, + 232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name as *const _ as usize + }, + 240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name16 as *const _ as usize + }, + 248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name as *const _ as usize + }, + 256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name16 as *const _ + as usize + }, + 264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name as *const _ as usize + }, + 272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name16 as *const _ + as usize + }, + 280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text as *const _ as usize + }, + 288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text16 as *const _ as usize + }, + 296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_type as *const _ as usize + }, + 304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_type) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_value as *const _ as usize + }, + 312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).commit_hook as *const _ as usize + }, + 320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(commit_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, + 328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, + 336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation as *const _ as usize + }, + 344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation16 as *const _ as usize + }, + 352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function as *const _ as usize + }, + 360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function16 as *const _ as usize + }, + 368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module as *const _ as usize + }, + 376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, + 384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(data_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, + 392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).declare_vtab as *const _ as usize + }, + 400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(declare_vtab) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).enable_shared_cache as *const _ + as usize + }, + 408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(enable_shared_cache) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, + 416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, + 424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, + 432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, + 440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(exec) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, + 448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(expired) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, + 456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(finalize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, + 464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, + 472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_autocommit as *const _ as usize + }, + 480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_autocommit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_auxdata as *const _ as usize + }, + 488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, + 496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).global_recover as *const _ as usize + }, + 504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(global_recover) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, + 512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(interruptx) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize + }, + 520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(last_insert_rowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, + 528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).libversion_number as *const _ as usize + }, + 536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion_number) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, + 544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, + 552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, + 560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, + 568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, + 576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, + 584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, + 592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(profile) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).progress_handler as *const _ as usize + }, + 600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(progress_handler) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, + 608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, + 616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob as *const _ as usize + }, + 624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_double as *const _ as usize + }, + 632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_double) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error as *const _ as usize + }, + 640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error16 as *const _ as usize + }, + 648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, + 656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_int64 as *const _ as usize + }, + 664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_null as *const _ as usize + }, + 672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text as *const _ as usize + }, + 680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16 as *const _ as usize + }, + 688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16be as *const _ as usize + }, + 696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16le as *const _ as usize + }, + 704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16le) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_value as *const _ as usize + }, + 712usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rollback_hook as *const _ as usize + }, + 720usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(rollback_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_authorizer as *const _ as usize + }, + 728usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_authorizer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_auxdata as *const _ as usize + }, + 736usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xsnprintf as *const _ as usize }, + 744usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xsnprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, + 752usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).table_column_metadata as *const _ + as usize + }, + 760usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(table_column_metadata) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize + }, + 768usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(thread_cleanup) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).total_changes as *const _ as usize + }, + 776usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(total_changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, + 784usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(trace) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize + }, + 792usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(transfer_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).update_hook as *const _ as usize + }, + 800usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(update_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, + 808usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(user_data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, + 816usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes as *const _ as usize + }, + 824usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize + }, + 832usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_double as *const _ as usize + }, + 840usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, + 848usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_int64 as *const _ as usize + }, + 856usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize + }, + 864usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_numeric_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, + 872usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16 as *const _ as usize + }, + 880usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16be as *const _ as usize + }, + 888usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16le as *const _ as usize + }, + 896usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16le) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, + 904usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, + 912usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vmprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).overload_function as *const _ as usize + }, + 920usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(overload_function) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, + 928usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize + }, + 936usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).clear_bindings as *const _ as usize + }, + 944usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(clear_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize + }, + 952usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize + }, + 960usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, + 968usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_bytes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, + 976usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_close) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, + 984usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, + 992usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_read) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, + 1000usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_write) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation_v2 as *const _ + as usize + }, + 1008usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).file_control as *const _ as usize + }, + 1016usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(file_control) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_highwater as *const _ as usize + }, + 1024usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_highwater) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_used as *const _ as usize + }, + 1032usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize + }, + 1040usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_alloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_enter as *const _ as usize + }, + 1048usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_enter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, + 1056usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_leave as *const _ as usize + }, + 1064usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_leave) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, + 1072usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_try) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, + 1080usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).release_memory as *const _ as usize + }, + 1088usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(release_memory) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize + }, + 1096usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_nomem) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_toobig as *const _ + as usize + }, + 1104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_toobig) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, + 1112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sleep) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize + }, + 1120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, + 1128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_find) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_register as *const _ as usize + }, + 1136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_register) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize + }, + 1144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_unregister) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize + }, + 1152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xthreadsafe) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize + }, + 1160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_code as *const _ as usize + }, + 1168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_code) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).test_control as *const _ as usize + }, + 1176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(test_control) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, + 1184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(randomness) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).context_db_handle as *const _ as usize + }, + 1192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(context_db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_result_codes as *const _ + as usize + }, + 1200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_result_codes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, + 1208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, + 1216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(next_stmt) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, + 1224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sql) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, + 1232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_finish as *const _ as usize + }, + 1240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_finish) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_init as *const _ as usize + }, + 1248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_init) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_pagecount as *const _ as usize + }, + 1256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_pagecount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_remaining as *const _ as usize + }, + 1264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_remaining) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_step as *const _ as usize + }, + 1272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_get as *const _ as usize + }, + 1280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_get) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_used as *const _ as usize + }, + 1288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function_v2 as *const _ as usize + }, + 1296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function_v2) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_config as *const _ as usize }, + 1304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_config) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_mutex as *const _ as usize }, + 1312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_mutex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_status as *const _ as usize }, + 1320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_errcode as *const _ as usize + }, + 1328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).log as *const _ as usize }, + 1336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(log) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit64 as *const _ as usize + }, + 1344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sourceid as *const _ as usize }, + 1352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sourceid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stmt_status as *const _ as usize + }, + 1360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_status) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strnicmp as *const _ as usize }, + 1368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strnicmp) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).unlock_notify as *const _ as usize + }, + 1376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(unlock_notify) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_autocheckpoint as *const _ as usize + }, + 1384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_autocheckpoint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_checkpoint as *const _ as usize + }, + 1392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_checkpoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).wal_hook as *const _ as usize }, + 1400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).blob_reopen as *const _ as usize + }, + 1408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_reopen) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_config as *const _ as usize + }, + 1416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_config) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_on_conflict as *const _ as usize + }, + 1424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_on_conflict) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close_v2 as *const _ as usize }, + 1432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_filename as *const _ as usize + }, + 1440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_filename) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_readonly as *const _ as usize + }, + 1448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_readonly) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_release_memory as *const _ as usize + }, + 1456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_release_memory) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errstr as *const _ as usize }, + 1464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errstr) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).stmt_busy as *const _ as usize }, + 1472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_busy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stmt_readonly as *const _ as usize + }, + 1480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_readonly) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).stricmp as *const _ as usize }, + 1488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stricmp) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).uri_boolean as *const _ as usize + }, + 1496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_boolean) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).uri_int64 as *const _ as usize }, + 1504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).uri_parameter as *const _ as usize + }, + 1512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_parameter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xvsnprintf as *const _ as usize }, + 1520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xvsnprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_checkpoint_v2 as *const _ as usize + }, + 1528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_checkpoint_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).auto_extension as *const _ as usize + }, + 1536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(auto_extension) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_blob64 as *const _ as usize + }, + 1544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text64 as *const _ as usize + }, + 1552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).cancel_auto_extension as *const _ + as usize + }, + 1560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(cancel_auto_extension) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).load_extension as *const _ as usize + }, + 1568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(load_extension) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc64 as *const _ as usize }, + 1576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).msize as *const _ as usize }, + 1584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(msize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc64 as *const _ as usize }, + 1592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).reset_auto_extension as *const _ + as usize + }, + 1600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset_auto_extension) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob64 as *const _ as usize + }, + 1608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text64 as *const _ as usize + }, + 1616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strglob as *const _ as usize }, + 1624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strglob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_dup as *const _ as usize }, + 1632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_dup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_free as *const _ as usize }, + 1640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob64 as *const _ as usize + }, + 1648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob64 as *const _ as usize + }, + 1656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_subtype as *const _ as usize + }, + 1664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_subtype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_subtype as *const _ as usize + }, + 1672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_subtype) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status64 as *const _ as usize }, + 1680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strlike as *const _ as usize }, + 1688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strlike) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_cacheflush as *const _ as usize + }, + 1696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_cacheflush) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).system_errno as *const _ as usize + }, + 1704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(system_errno) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).trace_v2 as *const _ as usize }, + 1712usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(trace_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).expanded_sql as *const _ as usize + }, + 1720usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(expanded_sql) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_last_insert_rowid as *const _ + as usize + }, + 1728usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_last_insert_rowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare_v3 as *const _ as usize }, + 1736usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare_v3) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).prepare16_v3 as *const _ as usize + }, + 1744usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16_v3) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_pointer as *const _ as usize + }, + 1752usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_pointer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_pointer as *const _ as usize + }, + 1760usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_pointer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_pointer as *const _ as usize + }, + 1768usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_pointer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_nochange as *const _ as usize + }, + 1776usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_nochange) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_nochange as *const _ as usize + }, + 1784usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_nochange) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_collation as *const _ as usize + }, + 1792usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_collation) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).keyword_count as *const _ as usize + }, + 1800usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(keyword_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).keyword_name as *const _ as usize + }, + 1808usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(keyword_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).keyword_check as *const _ as usize + }, + 1816usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(keyword_check) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).str_new as *const _ as usize }, + 1824usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_new) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).str_finish as *const _ as usize }, + 1832usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_finish) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).str_appendf as *const _ as usize + }, + 1840usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_appendf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).str_vappendf as *const _ as usize + }, + 1848usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_vappendf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).str_append as *const _ as usize }, + 1856usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_append) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).str_appendall as *const _ as usize + }, + 1864usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_appendall) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).str_appendchar as *const _ as usize + }, + 1872usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_appendchar) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).str_reset as *const _ as usize }, + 1880usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_reset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).str_errcode as *const _ as usize + }, + 1888usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).str_length as *const _ as usize }, + 1896usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_length) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).str_value as *const _ as usize }, + 1904usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_window_function as *const _ + as usize + }, + 1912usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_window_function) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).normalized_sql as *const _ as usize + }, + 1920usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(normalized_sql) + ) + ); +} +pub type sqlite3_loadext_entry = ::std::option::Option< + unsafe extern "C" fn( + db: *mut sqlite3, + pzErrMsg: *mut *mut ::std::os::raw::c_char, + pThunk: *const sqlite3_api_routines, + ) -> ::std::os::raw::c_int, +>; +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} + +// bindings were built with loadable_extension_embedded: +// define sqlite3_api as an extern since this code will be embedded +// within a loadable extension that defines and exports this itself +extern "C" { + #[no_mangle] + pub static mut sqlite3_api: *mut sqlite3_api_routines; +} + +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) + +pub unsafe fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_context.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_context", + " function" + )))(arg1, nBytes) +} + +pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_double", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_null", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_index.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_index", + " function" + )))(arg1, zName) +} + +pub unsafe fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_value", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_handler", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_timeout.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_timeout", + " function" + )))(arg1, ms) +} + +pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_blob", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype", + " function" + )))(arg1, i) +} + +pub unsafe fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_double", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int64", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_type", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_value", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).commit_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "commit_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete16", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_create_collation( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_collation16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_function( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_function16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function16", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_module( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).data_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "data_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).declare_vtab.expect(stringify!( + "sqlite3_api contains null pointer for ", + "declare_vtab", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).enable_shared_cache.expect(stringify!( + "sqlite3_api contains null pointer for ", + "enable_shared_cache", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errcode", + " function" + )))(db) +} + +pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_exec( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).exec.expect(stringify!( + "sqlite3_api contains null pointer for ", + "exec", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).expired.expect(stringify!( + "sqlite3_api contains null pointer for ", + "expired", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).finalize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "finalize", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free_table", + " function" + )))(result) +} + +pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_autocommit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_autocommit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_auxdata", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_get_table( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_table", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).global_recover.expect(stringify!( + "sqlite3_api contains null pointer for ", + "global_recover", + " function" + )))() +} + +pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).interruptx.expect(stringify!( + "sqlite3_api contains null pointer for ", + "interruptx", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).last_insert_rowid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "last_insert_rowid", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion", + " function" + )))() +} + +pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion_number.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion_number", + " function" + )))() +} + +pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mprintf( + arg1: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mprintf", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_open( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_open16( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_prepare( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_profile( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).profile.expect(stringify!( + "sqlite3_api contains null pointer for ", + "profile", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).progress_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "progress_handler", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_double", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_null", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16be", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16le", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_value", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).rollback_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "rollback_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_authorizer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_authorizer", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_auxdata", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_xsnprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xsnprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xsnprintf", + " function" + )))(arg1, arg2, arg3, vararg1) +} + +pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "step", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_table_column_metadata( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).table_column_metadata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "table_column_metadata", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) +} + +pub unsafe fn sqlite3_thread_cleanup() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).thread_cleanup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "thread_cleanup", + " function" + )))() +} + +pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).total_changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "total_changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).trace.expect(stringify!( + "sqlite3_api contains null pointer for ", + "trace", + " function" + )))(arg1, xTrace, arg2) +} + +pub unsafe fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).transfer_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "transfer_bindings", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).update_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "update_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).user_data.expect(stringify!( + "sqlite3_api contains null pointer for ", + "user_data", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_blob", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_double", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_numeric_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_numeric_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16be", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16le", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vmprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vmprintf", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).overload_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "overload_function", + " function" + )))(arg1, zFuncName, nArg) +} + +pub unsafe fn sqlite3_prepare_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).clear_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "clear_bindings", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_module_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module_v2", + " function" + )))(arg1, arg2, arg3, arg4, xDestroy) +} + +pub unsafe fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_open( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_open", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) +} + +pub unsafe fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_read.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_read", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_write.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_write", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_file_control( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).file_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "file_control", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_highwater.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_highwater", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_used", + " function" + )))() +} + +pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_alloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_alloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_enter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_enter", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_leave.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_leave", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_try.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_try", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_open_v2( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open_v2", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_nomem.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_nomem", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_toobig.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_toobig", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sleep.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sleep", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_find.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_find", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_register.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_register", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_unregister.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_unregister", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xthreadsafe.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xthreadsafe", + " function" + )))() +} + +pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_code.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_code", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_test_control( + arg1: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).test_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "test_control", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).randomness.expect(stringify!( + "sqlite3_api contains null pointer for ", + "randomness", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).context_db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "context_db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_result_codes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_result_codes", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_limit( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "limit", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).next_stmt.expect(stringify!( + "sqlite3_api contains null pointer for ", + "next_stmt", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_status( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_finish.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_finish", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_init( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, +) -> *mut sqlite3_backup { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_init.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_init", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_pagecount.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_pagecount", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_remaining.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_remaining", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_step( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_step", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_compileoption_get( + arg1: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_get.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_get", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_compileoption_used( + arg1: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_used", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_function_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal, xDestroy) +} + +pub unsafe fn sqlite3_db_config( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, + vararg2: &mut i32, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_config", + " function" + )))(arg1, arg2, vararg1, vararg2) +} + +pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_mutex.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_mutex", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_db_status( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_status", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_errcode", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_log( + arg1: ::std::os::raw::c_int, + arg2: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).log.expect(stringify!( + "sqlite3_api contains null pointer for ", + "log", + " function" + )))(arg1, arg2, vararg1) +} + +pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sourceid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sourceid", + " function" + )))() +} + +pub unsafe fn sqlite3_stmt_status( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_status", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_strnicmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strnicmp.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strnicmp", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_unlock_notify( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int), + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).unlock_notify.expect(stringify!( + "sqlite3_api contains null pointer for ", + "unlock_notify", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_wal_autocheckpoint( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_autocheckpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_checkpoint( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_checkpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_checkpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_reopen( + arg1: *mut sqlite3_blob, + arg2: sqlite3_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_reopen.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_reopen", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vtab_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_config", + " function" + )))(arg1, op, vararg1) +} + +pub unsafe fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_on_conflict.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_on_conflict", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close_v2", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_db_filename( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_filename.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_filename", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_db_readonly( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_readonly.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_readonly", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errstr.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errstr", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_busy.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_busy", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stmt_readonly(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_readonly.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_readonly", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stricmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stricmp.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stricmp", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_uri_boolean( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_boolean.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_boolean", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_uri_int64( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64, +) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_uri_parameter( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_parameter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_parameter", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_xvsnprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xvsnprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xvsnprintf", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_wal_checkpoint_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_checkpoint_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_checkpoint_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_auto_extension( + arg1: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).auto_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "auto_extension", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob64", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_text64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + arg6: ::std::os::raw::c_uchar, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text64", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_cancel_auto_extension( + arg1: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).cancel_auto_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "cancel_auto_extension", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_load_extension( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).load_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "load_extension", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_malloc64(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_msize(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).msize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "msize", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_realloc64( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_uint64, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset_auto_extension() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset_auto_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset_auto_extension", + " function" + )))() +} + +pub unsafe fn sqlite3_result_blob64( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob64", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text64( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + arg5: ::std::os::raw::c_uchar, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text64", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_strglob( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strglob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strglob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_value_dup(arg1: *const sqlite3_value) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_dup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_dup", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_free(arg1: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_zeroblob64( + arg1: *mut sqlite3_context, + arg2: sqlite3_uint64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_zeroblob64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_uint64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_value_subtype(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_subtype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_subtype", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_subtype(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_subtype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_subtype", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_status64( + arg1: ::std::os::raw::c_int, + arg2: *mut sqlite3_int64, + arg3: *mut sqlite3_int64, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status64", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_strlike( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_uint, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strlike.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strlike", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_db_cacheflush(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_cacheflush.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_cacheflush", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_system_errno(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).system_errno.expect(stringify!( + "sqlite3_api contains null pointer for ", + "system_errno", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_trace_v2( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_uint, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_uint, + arg2: *mut ::std::os::raw::c_void, + arg3: *mut ::std::os::raw::c_void, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).trace_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "trace_v2", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_expanded_sql(arg1: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).expanded_sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "expanded_sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_set_last_insert_rowid(arg1: *mut sqlite3, arg2: sqlite3_int64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_last_insert_rowid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_last_insert_rowid", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_prepare_v3( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_uint, + arg5: *mut *mut sqlite3_stmt, + arg6: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare_v3.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare_v3", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_prepare16_v3( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_uint, + arg5: *mut *mut sqlite3_stmt, + arg6: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16_v3.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16_v3", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_bind_pointer( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: *const ::std::os::raw::c_char, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_pointer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_pointer", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_result_pointer( + arg1: *mut sqlite3_context, + arg2: *mut ::std::os::raw::c_void, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_pointer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_pointer", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_value_pointer( + arg1: *mut sqlite3_value, + arg2: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_pointer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_pointer", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vtab_nochange(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_nochange.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_nochange", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_nochange(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_nochange.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_nochange", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vtab_collation( + arg1: *mut sqlite3_index_info, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_collation.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_collation", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_keyword_count() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).keyword_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "keyword_count", + " function" + )))() +} + +pub unsafe fn sqlite3_keyword_name( + arg1: ::std::os::raw::c_int, + arg2: *mut *const ::std::os::raw::c_char, + arg3: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).keyword_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "keyword_name", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_keyword_check( + arg1: *const ::std::os::raw::c_char, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).keyword_check.expect(stringify!( + "sqlite3_api contains null pointer for ", + "keyword_check", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_str_new(arg1: *mut sqlite3) -> *mut sqlite3_str { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_new.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_new", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_str_finish(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_finish.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_finish", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_str_appendf( + arg1: *mut sqlite3_str, + zFormat: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_appendf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_appendf", + " function" + )))(arg1, zFormat, vararg1) +} + +pub unsafe fn sqlite3_str_vappendf( + arg1: *mut sqlite3_str, + zFormat: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_vappendf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_vappendf", + " function" + )))(arg1, zFormat, arg2) +} + +pub unsafe fn sqlite3_str_append( + arg1: *mut sqlite3_str, + zIn: *const ::std::os::raw::c_char, + N: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_append.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_append", + " function" + )))(arg1, zIn, N) +} + +pub unsafe fn sqlite3_str_appendall(arg1: *mut sqlite3_str, zIn: *const ::std::os::raw::c_char) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_appendall.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_appendall", + " function" + )))(arg1, zIn) +} + +pub unsafe fn sqlite3_str_appendchar( + arg1: *mut sqlite3_str, + N: ::std::os::raw::c_int, + C: ::std::os::raw::c_char, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_appendchar.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_appendchar", + " function" + )))(arg1, N, C) +} + +pub unsafe fn sqlite3_str_reset(arg1: *mut sqlite3_str) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_reset.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_reset", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_str_errcode(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_errcode", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_str_length(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_length.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_length", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_str_value(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_value", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_window_function( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xValue: ::std::option::Option, + xInv: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_window_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_window_function", + " function" + )))( + arg1, arg2, arg3, arg4, arg5, xStep, xFinal, xValue, xInv, xDestroy, + ) +} + +pub unsafe fn sqlite3_normalized_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).normalized_sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "normalized_sql", + " function" + )))(arg1) +} diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.26.0-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.26.0-ext.rs new file mode 100644 index 000000000..5aafee43e --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.26.0-ext.rs @@ -0,0 +1,11138 @@ +/* automatically generated by rust-bindgen */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.26.0\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3026000; +pub const SQLITE_SOURCE_ID: &'static [u8; 85usize] = + b"2018-12-01 12:34:55 bf8c1b2b7a5960c282e543b9c293686dccff272512d08865f4600fb58238b4f9\0"; +pub const SQLITE_OK: i32 = 0; +pub const SQLITE_ERROR: i32 = 1; +pub const SQLITE_INTERNAL: i32 = 2; +pub const SQLITE_PERM: i32 = 3; +pub const SQLITE_ABORT: i32 = 4; +pub const SQLITE_BUSY: i32 = 5; +pub const SQLITE_LOCKED: i32 = 6; +pub const SQLITE_NOMEM: i32 = 7; +pub const SQLITE_READONLY: i32 = 8; +pub const SQLITE_INTERRUPT: i32 = 9; +pub const SQLITE_IOERR: i32 = 10; +pub const SQLITE_CORRUPT: i32 = 11; +pub const SQLITE_NOTFOUND: i32 = 12; +pub const SQLITE_FULL: i32 = 13; +pub const SQLITE_CANTOPEN: i32 = 14; +pub const SQLITE_PROTOCOL: i32 = 15; +pub const SQLITE_EMPTY: i32 = 16; +pub const SQLITE_SCHEMA: i32 = 17; +pub const SQLITE_TOOBIG: i32 = 18; +pub const SQLITE_CONSTRAINT: i32 = 19; +pub const SQLITE_MISMATCH: i32 = 20; +pub const SQLITE_MISUSE: i32 = 21; +pub const SQLITE_NOLFS: i32 = 22; +pub const SQLITE_AUTH: i32 = 23; +pub const SQLITE_FORMAT: i32 = 24; +pub const SQLITE_RANGE: i32 = 25; +pub const SQLITE_NOTADB: i32 = 26; +pub const SQLITE_NOTICE: i32 = 27; +pub const SQLITE_WARNING: i32 = 28; +pub const SQLITE_ROW: i32 = 100; +pub const SQLITE_DONE: i32 = 101; +pub const SQLITE_ERROR_MISSING_COLLSEQ: i32 = 257; +pub const SQLITE_ERROR_RETRY: i32 = 513; +pub const SQLITE_ERROR_SNAPSHOT: i32 = 769; +pub const SQLITE_IOERR_READ: i32 = 266; +pub const SQLITE_IOERR_SHORT_READ: i32 = 522; +pub const SQLITE_IOERR_WRITE: i32 = 778; +pub const SQLITE_IOERR_FSYNC: i32 = 1034; +pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; +pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; +pub const SQLITE_IOERR_FSTAT: i32 = 1802; +pub const SQLITE_IOERR_UNLOCK: i32 = 2058; +pub const SQLITE_IOERR_RDLOCK: i32 = 2314; +pub const SQLITE_IOERR_DELETE: i32 = 2570; +pub const SQLITE_IOERR_BLOCKED: i32 = 2826; +pub const SQLITE_IOERR_NOMEM: i32 = 3082; +pub const SQLITE_IOERR_ACCESS: i32 = 3338; +pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; +pub const SQLITE_IOERR_LOCK: i32 = 3850; +pub const SQLITE_IOERR_CLOSE: i32 = 4106; +pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; +pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; +pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; +pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; +pub const SQLITE_IOERR_SHMMAP: i32 = 5386; +pub const SQLITE_IOERR_SEEK: i32 = 5642; +pub const SQLITE_IOERR_DELETE_NOENT: i32 = 5898; +pub const SQLITE_IOERR_MMAP: i32 = 6154; +pub const SQLITE_IOERR_GETTEMPPATH: i32 = 6410; +pub const SQLITE_IOERR_CONVPATH: i32 = 6666; +pub const SQLITE_IOERR_VNODE: i32 = 6922; +pub const SQLITE_IOERR_AUTH: i32 = 7178; +pub const SQLITE_IOERR_BEGIN_ATOMIC: i32 = 7434; +pub const SQLITE_IOERR_COMMIT_ATOMIC: i32 = 7690; +pub const SQLITE_IOERR_ROLLBACK_ATOMIC: i32 = 7946; +pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; +pub const SQLITE_LOCKED_VTAB: i32 = 518; +pub const SQLITE_BUSY_RECOVERY: i32 = 261; +pub const SQLITE_BUSY_SNAPSHOT: i32 = 517; +pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; +pub const SQLITE_CANTOPEN_ISDIR: i32 = 526; +pub const SQLITE_CANTOPEN_FULLPATH: i32 = 782; +pub const SQLITE_CANTOPEN_CONVPATH: i32 = 1038; +pub const SQLITE_CANTOPEN_DIRTYWAL: i32 = 1294; +pub const SQLITE_CORRUPT_VTAB: i32 = 267; +pub const SQLITE_CORRUPT_SEQUENCE: i32 = 523; +pub const SQLITE_READONLY_RECOVERY: i32 = 264; +pub const SQLITE_READONLY_CANTLOCK: i32 = 520; +pub const SQLITE_READONLY_ROLLBACK: i32 = 776; +pub const SQLITE_READONLY_DBMOVED: i32 = 1032; +pub const SQLITE_READONLY_CANTINIT: i32 = 1288; +pub const SQLITE_READONLY_DIRECTORY: i32 = 1544; +pub const SQLITE_ABORT_ROLLBACK: i32 = 516; +pub const SQLITE_CONSTRAINT_CHECK: i32 = 275; +pub const SQLITE_CONSTRAINT_COMMITHOOK: i32 = 531; +pub const SQLITE_CONSTRAINT_FOREIGNKEY: i32 = 787; +pub const SQLITE_CONSTRAINT_FUNCTION: i32 = 1043; +pub const SQLITE_CONSTRAINT_NOTNULL: i32 = 1299; +pub const SQLITE_CONSTRAINT_PRIMARYKEY: i32 = 1555; +pub const SQLITE_CONSTRAINT_TRIGGER: i32 = 1811; +pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067; +pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323; +pub const SQLITE_CONSTRAINT_ROWID: i32 = 2579; +pub const SQLITE_NOTICE_RECOVER_WAL: i32 = 283; +pub const SQLITE_NOTICE_RECOVER_ROLLBACK: i32 = 539; +pub const SQLITE_WARNING_AUTOINDEX: i32 = 284; +pub const SQLITE_AUTH_USER: i32 = 279; +pub const SQLITE_OK_LOAD_PERMANENTLY: i32 = 256; +pub const SQLITE_OPEN_READONLY: i32 = 1; +pub const SQLITE_OPEN_READWRITE: i32 = 2; +pub const SQLITE_OPEN_CREATE: i32 = 4; +pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; +pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; +pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; +pub const SQLITE_OPEN_URI: i32 = 64; +pub const SQLITE_OPEN_MEMORY: i32 = 128; +pub const SQLITE_OPEN_MAIN_DB: i32 = 256; +pub const SQLITE_OPEN_TEMP_DB: i32 = 512; +pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; +pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; +pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; +pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; +pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; +pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; +pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; +pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; +pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; +pub const SQLITE_OPEN_WAL: i32 = 524288; +pub const SQLITE_IOCAP_ATOMIC: i32 = 1; +pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; +pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; +pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; +pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; +pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; +pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; +pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; +pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; +pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; +pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; +pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; +pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE: i32 = 4096; +pub const SQLITE_IOCAP_IMMUTABLE: i32 = 8192; +pub const SQLITE_IOCAP_BATCH_ATOMIC: i32 = 16384; +pub const SQLITE_LOCK_NONE: i32 = 0; +pub const SQLITE_LOCK_SHARED: i32 = 1; +pub const SQLITE_LOCK_RESERVED: i32 = 2; +pub const SQLITE_LOCK_PENDING: i32 = 3; +pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; +pub const SQLITE_SYNC_NORMAL: i32 = 2; +pub const SQLITE_SYNC_FULL: i32 = 3; +pub const SQLITE_SYNC_DATAONLY: i32 = 16; +pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; +pub const SQLITE_FCNTL_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_FCNTL_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_FCNTL_LAST_ERRNO: i32 = 4; +pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; +pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; +pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; +pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; +pub const SQLITE_FCNTL_WIN32_AV_RETRY: i32 = 9; +pub const SQLITE_FCNTL_PERSIST_WAL: i32 = 10; +pub const SQLITE_FCNTL_OVERWRITE: i32 = 11; +pub const SQLITE_FCNTL_VFSNAME: i32 = 12; +pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE: i32 = 13; +pub const SQLITE_FCNTL_PRAGMA: i32 = 14; +pub const SQLITE_FCNTL_BUSYHANDLER: i32 = 15; +pub const SQLITE_FCNTL_TEMPFILENAME: i32 = 16; +pub const SQLITE_FCNTL_MMAP_SIZE: i32 = 18; +pub const SQLITE_FCNTL_TRACE: i32 = 19; +pub const SQLITE_FCNTL_HAS_MOVED: i32 = 20; +pub const SQLITE_FCNTL_SYNC: i32 = 21; +pub const SQLITE_FCNTL_COMMIT_PHASETWO: i32 = 22; +pub const SQLITE_FCNTL_WIN32_SET_HANDLE: i32 = 23; +pub const SQLITE_FCNTL_WAL_BLOCK: i32 = 24; +pub const SQLITE_FCNTL_ZIPVFS: i32 = 25; +pub const SQLITE_FCNTL_RBU: i32 = 26; +pub const SQLITE_FCNTL_VFS_POINTER: i32 = 27; +pub const SQLITE_FCNTL_JOURNAL_POINTER: i32 = 28; +pub const SQLITE_FCNTL_WIN32_GET_HANDLE: i32 = 29; +pub const SQLITE_FCNTL_PDB: i32 = 30; +pub const SQLITE_FCNTL_BEGIN_ATOMIC_WRITE: i32 = 31; +pub const SQLITE_FCNTL_COMMIT_ATOMIC_WRITE: i32 = 32; +pub const SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE: i32 = 33; +pub const SQLITE_FCNTL_LOCK_TIMEOUT: i32 = 34; +pub const SQLITE_FCNTL_DATA_VERSION: i32 = 35; +pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_LAST_ERRNO: i32 = 4; +pub const SQLITE_ACCESS_EXISTS: i32 = 0; +pub const SQLITE_ACCESS_READWRITE: i32 = 1; +pub const SQLITE_ACCESS_READ: i32 = 2; +pub const SQLITE_SHM_UNLOCK: i32 = 1; +pub const SQLITE_SHM_LOCK: i32 = 2; +pub const SQLITE_SHM_SHARED: i32 = 4; +pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; +pub const SQLITE_SHM_NLOCK: i32 = 8; +pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; +pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; +pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; +pub const SQLITE_CONFIG_MALLOC: i32 = 4; +pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; +pub const SQLITE_CONFIG_SCRATCH: i32 = 6; +pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; +pub const SQLITE_CONFIG_HEAP: i32 = 8; +pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; +pub const SQLITE_CONFIG_MUTEX: i32 = 10; +pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; +pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; +pub const SQLITE_CONFIG_PCACHE: i32 = 14; +pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; +pub const SQLITE_CONFIG_LOG: i32 = 16; +pub const SQLITE_CONFIG_URI: i32 = 17; +pub const SQLITE_CONFIG_PCACHE2: i32 = 18; +pub const SQLITE_CONFIG_GETPCACHE2: i32 = 19; +pub const SQLITE_CONFIG_COVERING_INDEX_SCAN: i32 = 20; +pub const SQLITE_CONFIG_SQLLOG: i32 = 21; +pub const SQLITE_CONFIG_MMAP_SIZE: i32 = 22; +pub const SQLITE_CONFIG_WIN32_HEAPSIZE: i32 = 23; +pub const SQLITE_CONFIG_PCACHE_HDRSZ: i32 = 24; +pub const SQLITE_CONFIG_PMASZ: i32 = 25; +pub const SQLITE_CONFIG_STMTJRNL_SPILL: i32 = 26; +pub const SQLITE_CONFIG_SMALL_MALLOC: i32 = 27; +pub const SQLITE_CONFIG_SORTERREF_SIZE: i32 = 28; +pub const SQLITE_DBCONFIG_MAINDBNAME: i32 = 1000; +pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; +pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; +pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; +pub const SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: i32 = 1004; +pub const SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: i32 = 1005; +pub const SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE: i32 = 1006; +pub const SQLITE_DBCONFIG_ENABLE_QPSG: i32 = 1007; +pub const SQLITE_DBCONFIG_TRIGGER_EQP: i32 = 1008; +pub const SQLITE_DBCONFIG_RESET_DATABASE: i32 = 1009; +pub const SQLITE_DBCONFIG_DEFENSIVE: i32 = 1010; +pub const SQLITE_DBCONFIG_MAX: i32 = 1010; +pub const SQLITE_DENY: i32 = 1; +pub const SQLITE_IGNORE: i32 = 2; +pub const SQLITE_CREATE_INDEX: i32 = 1; +pub const SQLITE_CREATE_TABLE: i32 = 2; +pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; +pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; +pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; +pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; +pub const SQLITE_CREATE_TRIGGER: i32 = 7; +pub const SQLITE_CREATE_VIEW: i32 = 8; +pub const SQLITE_DELETE: i32 = 9; +pub const SQLITE_DROP_INDEX: i32 = 10; +pub const SQLITE_DROP_TABLE: i32 = 11; +pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; +pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; +pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; +pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; +pub const SQLITE_DROP_TRIGGER: i32 = 16; +pub const SQLITE_DROP_VIEW: i32 = 17; +pub const SQLITE_INSERT: i32 = 18; +pub const SQLITE_PRAGMA: i32 = 19; +pub const SQLITE_READ: i32 = 20; +pub const SQLITE_SELECT: i32 = 21; +pub const SQLITE_TRANSACTION: i32 = 22; +pub const SQLITE_UPDATE: i32 = 23; +pub const SQLITE_ATTACH: i32 = 24; +pub const SQLITE_DETACH: i32 = 25; +pub const SQLITE_ALTER_TABLE: i32 = 26; +pub const SQLITE_REINDEX: i32 = 27; +pub const SQLITE_ANALYZE: i32 = 28; +pub const SQLITE_CREATE_VTABLE: i32 = 29; +pub const SQLITE_DROP_VTABLE: i32 = 30; +pub const SQLITE_FUNCTION: i32 = 31; +pub const SQLITE_SAVEPOINT: i32 = 32; +pub const SQLITE_COPY: i32 = 0; +pub const SQLITE_RECURSIVE: i32 = 33; +pub const SQLITE_TRACE_STMT: i32 = 1; +pub const SQLITE_TRACE_PROFILE: i32 = 2; +pub const SQLITE_TRACE_ROW: i32 = 4; +pub const SQLITE_TRACE_CLOSE: i32 = 8; +pub const SQLITE_LIMIT_LENGTH: i32 = 0; +pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; +pub const SQLITE_LIMIT_COLUMN: i32 = 2; +pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; +pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; +pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; +pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; +pub const SQLITE_LIMIT_ATTACHED: i32 = 7; +pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; +pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; +pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; +pub const SQLITE_LIMIT_WORKER_THREADS: i32 = 11; +pub const SQLITE_PREPARE_PERSISTENT: i32 = 1; +pub const SQLITE_PREPARE_NORMALIZE: i32 = 2; +pub const SQLITE_INTEGER: i32 = 1; +pub const SQLITE_FLOAT: i32 = 2; +pub const SQLITE_BLOB: i32 = 4; +pub const SQLITE_NULL: i32 = 5; +pub const SQLITE_TEXT: i32 = 3; +pub const SQLITE3_TEXT: i32 = 3; +pub const SQLITE_UTF8: i32 = 1; +pub const SQLITE_UTF16LE: i32 = 2; +pub const SQLITE_UTF16BE: i32 = 3; +pub const SQLITE_UTF16: i32 = 4; +pub const SQLITE_ANY: i32 = 5; +pub const SQLITE_UTF16_ALIGNED: i32 = 8; +pub const SQLITE_DETERMINISTIC: i32 = 2048; +pub const SQLITE_WIN32_DATA_DIRECTORY_TYPE: i32 = 1; +pub const SQLITE_WIN32_TEMP_DIRECTORY_TYPE: i32 = 2; +pub const SQLITE_INDEX_SCAN_UNIQUE: i32 = 1; +pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; +pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; +pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; +pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; +pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; +pub const SQLITE_INDEX_CONSTRAINT_LIKE: i32 = 65; +pub const SQLITE_INDEX_CONSTRAINT_GLOB: i32 = 66; +pub const SQLITE_INDEX_CONSTRAINT_REGEXP: i32 = 67; +pub const SQLITE_INDEX_CONSTRAINT_NE: i32 = 68; +pub const SQLITE_INDEX_CONSTRAINT_ISNOT: i32 = 69; +pub const SQLITE_INDEX_CONSTRAINT_ISNOTNULL: i32 = 70; +pub const SQLITE_INDEX_CONSTRAINT_ISNULL: i32 = 71; +pub const SQLITE_INDEX_CONSTRAINT_IS: i32 = 72; +pub const SQLITE_INDEX_CONSTRAINT_FUNCTION: i32 = 150; +pub const SQLITE_MUTEX_FAST: i32 = 0; +pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; +pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; +pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; +pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; +pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; +pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; +pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; +pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; +pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; +pub const SQLITE_MUTEX_STATIC_APP1: i32 = 8; +pub const SQLITE_MUTEX_STATIC_APP2: i32 = 9; +pub const SQLITE_MUTEX_STATIC_APP3: i32 = 10; +pub const SQLITE_MUTEX_STATIC_VFS1: i32 = 11; +pub const SQLITE_MUTEX_STATIC_VFS2: i32 = 12; +pub const SQLITE_MUTEX_STATIC_VFS3: i32 = 13; +pub const SQLITE_TESTCTRL_FIRST: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; +pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; +pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; +pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; +pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; +pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; +pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; +pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; +pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; +pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; +pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; +pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 17; +pub const SQLITE_TESTCTRL_INTERNAL_FUNCTIONS: i32 = 17; +pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 18; +pub const SQLITE_TESTCTRL_EXPLAIN_STMT: i32 = 19; +pub const SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD: i32 = 19; +pub const SQLITE_TESTCTRL_NEVER_CORRUPT: i32 = 20; +pub const SQLITE_TESTCTRL_VDBE_COVERAGE: i32 = 21; +pub const SQLITE_TESTCTRL_BYTEORDER: i32 = 22; +pub const SQLITE_TESTCTRL_ISINIT: i32 = 23; +pub const SQLITE_TESTCTRL_SORTER_MMAP: i32 = 24; +pub const SQLITE_TESTCTRL_IMPOSTER: i32 = 25; +pub const SQLITE_TESTCTRL_PARSER_COVERAGE: i32 = 26; +pub const SQLITE_TESTCTRL_LAST: i32 = 26; +pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; +pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; +pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; +pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; +pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; +pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; +pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; +pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; +pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; +pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; +pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; +pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; +pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; +pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; +pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; +pub const SQLITE_DBSTATUS_CACHE_HIT: i32 = 7; +pub const SQLITE_DBSTATUS_CACHE_MISS: i32 = 8; +pub const SQLITE_DBSTATUS_CACHE_WRITE: i32 = 9; +pub const SQLITE_DBSTATUS_DEFERRED_FKS: i32 = 10; +pub const SQLITE_DBSTATUS_CACHE_USED_SHARED: i32 = 11; +pub const SQLITE_DBSTATUS_CACHE_SPILL: i32 = 12; +pub const SQLITE_DBSTATUS_MAX: i32 = 12; +pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; +pub const SQLITE_STMTSTATUS_SORT: i32 = 2; +pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; +pub const SQLITE_STMTSTATUS_VM_STEP: i32 = 4; +pub const SQLITE_STMTSTATUS_REPREPARE: i32 = 5; +pub const SQLITE_STMTSTATUS_RUN: i32 = 6; +pub const SQLITE_STMTSTATUS_MEMUSED: i32 = 99; +pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; +pub const SQLITE_CHECKPOINT_FULL: i32 = 1; +pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; +pub const SQLITE_CHECKPOINT_TRUNCATE: i32 = 3; +pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; +pub const SQLITE_ROLLBACK: i32 = 1; +pub const SQLITE_FAIL: i32 = 3; +pub const SQLITE_REPLACE: i32 = 5; +pub const SQLITE_SCANSTAT_NLOOP: i32 = 0; +pub const SQLITE_SCANSTAT_NVISIT: i32 = 1; +pub const SQLITE_SCANSTAT_EST: i32 = 2; +pub const SQLITE_SCANSTAT_NAME: i32 = 3; +pub const SQLITE_SCANSTAT_EXPLAIN: i32 = 4; +pub const SQLITE_SCANSTAT_SELECTID: i32 = 5; +pub const SQLITE_SERIALIZE_NOCOPY: i32 = 1; +pub const SQLITE_DESERIALIZE_FREEONCLOSE: i32 = 1; +pub const SQLITE_DESERIALIZE_RESIZEABLE: i32 = 2; +pub const SQLITE_DESERIALIZE_READONLY: i32 = 4; +pub const NOT_WITHIN: i32 = 0; +pub const PARTLY_WITHIN: i32 = 1; +pub const FULLY_WITHIN: i32 = 2; +pub const FTS5_TOKENIZE_QUERY: i32 = 1; +pub const FTS5_TOKENIZE_PREFIX: i32 = 2; +pub const FTS5_TOKENIZE_DOCUMENT: i32 = 4; +pub const FTS5_TOKENIZE_AUX: i32 = 8; +pub const FTS5_TOKEN_COLOCATED: i32 = 1; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; +extern "C" { + #[link_name = "\u{1}sqlite3_version"] + pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3 { + _unused: [u8; 0], +} +pub type sqlite_int64 = ::std::os::raw::c_longlong; +pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; +pub type sqlite3_int64 = sqlite_int64; +pub type sqlite3_uint64 = sqlite_uint64; +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_file { + pub pMethods: *const sqlite3_io_methods, +} +#[test] +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xShmMap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iPg: ::std::os::raw::c_int, + pgsz: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xShmLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + offset: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xShmBarrier: ::std::option::Option, + pub xShmUnmap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + deleteFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iOfst: sqlite3_int64, + iAmt: ::std::os::raw::c_int, + pp: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xUnfetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iOfst: sqlite3_int64, + p: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 152usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmMap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmBarrier) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmUnmap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnfetch as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnfetch) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +pub type sqlite3_syscall_ptr = ::std::option::Option; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vfs { + pub iVersion: ::std::os::raw::c_int, + pub szOsFile: ::std::os::raw::c_int, + pub mxPathname: ::std::os::raw::c_int, + pub pNext: *mut sqlite3_vfs, + pub zName: *const ::std::os::raw::c_char, + pub pAppData: *mut ::std::os::raw::c_void, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTimeInt64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xSetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: sqlite3_syscall_ptr, + ) -> ::std::os::raw::c_int, + >, + pub xGetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> sqlite3_syscall_ptr, + >, + pub xNextSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_vfs() { + assert_eq!( + ::std::mem::size_of::(), + 168usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTimeInt64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xNextSystemCall) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mem_methods { + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub pAppData: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_mem_methods() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_stmt { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_value { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_context { + _unused: [u8; 0], +} +pub type sqlite3_destructor_type = + ::std::option::Option; +extern "C" { + #[link_name = "\u{1}sqlite3_temp_directory"] + pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "\u{1}sqlite3_data_directory"] + pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSavepoint: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRelease: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRollbackTo: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xShadowName: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 192usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSavepoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRelease) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollbackTo) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShadowName as *const _ as usize }, + 184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xShadowName) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info { + pub nConstraint: ::std::os::raw::c_int, + pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, + pub nOrderBy: ::std::os::raw::c_int, + pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, + pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, + pub idxNum: ::std::os::raw::c_int, + pub idxStr: *mut ::std::os::raw::c_char, + pub needToFreeIdxStr: ::std::os::raw::c_int, + pub orderByConsumed: ::std::os::raw::c_int, + pub estimatedCost: f64, + pub estimatedRows: sqlite3_int64, + pub idxFlags: ::std::os::raw::c_int, + pub colUsed: sqlite3_uint64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint { + pub iColumn: ::std::os::raw::c_int, + pub op: ::std::os::raw::c_uchar, + pub usable: ::std::os::raw::c_uchar, + pub iTermOffset: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_orderby { + pub iColumn: ::std::os::raw::c_int, + pub desc: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint_usage { + pub argvIndex: ::std::os::raw::c_int, + pub omit: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); +} +#[test] +fn bindgen_test_layout_sqlite3_index_info() { + assert_eq!( + ::std::mem::size_of::(), + 96usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedRows as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedRows) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxFlags as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxFlags) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).colUsed as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(colUsed) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_blob { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex_methods { + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_mutex_methods() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_str { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_page { + pub pBuf: *mut ::std::os::raw::c_void, + pub pExtra: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_page() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pBuf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pExtra) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods2 { + pub iVersion: ::std::os::raw::c_int, + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + szExtra: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache_page, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, + pub xShrink: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods2() { + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iVersion as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDestroy as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShrink) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods { + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_backup { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct sqlite3_snapshot { + pub hidden: [::std::os::raw::c_uchar; 48usize], +} +#[test] +fn bindgen_test_layout_sqlite3_snapshot() { + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!("Size of: ", stringify!(sqlite3_snapshot)) + ); + assert_eq!( + ::std::mem::align_of::(), + 1usize, + concat!("Alignment of ", stringify!(sqlite3_snapshot)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).hidden as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_snapshot), + "::", + stringify!(hidden) + ) + ); +} +pub type sqlite3_rtree_dbl = f64; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_geometry { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut sqlite3_rtree_dbl, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_geometry() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(xDelUser) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_query_info { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut sqlite3_rtree_dbl, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, + pub aCoord: *mut sqlite3_rtree_dbl, + pub anQueue: *mut ::std::os::raw::c_uint, + pub nCoord: ::std::os::raw::c_int, + pub iLevel: ::std::os::raw::c_int, + pub mxLevel: ::std::os::raw::c_int, + pub iRowid: sqlite3_int64, + pub rParentScore: sqlite3_rtree_dbl, + pub eParentWithin: ::std::os::raw::c_int, + pub eWithin: ::std::os::raw::c_int, + pub rScore: sqlite3_rtree_dbl, + pub apSqlParam: *mut *mut sqlite3_value, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_query_info() { + assert_eq!( + ::std::mem::size_of::(), + 112usize, + concat!("Size of: ", stringify!(sqlite3_rtree_query_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_query_info)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).pContext as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDelUser as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(xDelUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aCoord as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(aCoord) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).anQueue as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(anQueue) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nCoord as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(nCoord) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iLevel as *const _ as usize }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(iLevel) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mxLevel as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(mxLevel) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iRowid as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(iRowid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rParentScore as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(rParentScore) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eParentWithin as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(eParentWithin) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eWithin as *const _ as usize + }, + 92usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(eWithin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).rScore as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(rScore) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).apSqlParam as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(apSqlParam) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5Context { + _unused: [u8; 0], +} +pub type fts5_extension_function = ::std::option::Option< + unsafe extern "C" fn( + pApi: *const Fts5ExtensionApi, + pFts: *mut Fts5Context, + pCtx: *mut sqlite3_context, + nVal: ::std::os::raw::c_int, + apVal: *mut *mut sqlite3_value, + ), +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5PhraseIter { + pub a: *const ::std::os::raw::c_uchar, + pub b: *const ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_Fts5PhraseIter() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Fts5PhraseIter)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Fts5PhraseIter)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).a as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Fts5PhraseIter), + "::", + stringify!(a) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).b as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Fts5PhraseIter), + "::", + stringify!(b) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5ExtensionApi { + pub iVersion: ::std::os::raw::c_int, + pub xUserData: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> *mut ::std::os::raw::c_void, + >, + pub xColumnCount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, + >, + pub xRowCount: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pnRow: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xColumnTotalSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pnToken: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTokenize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pText: *const ::std::os::raw::c_char, + nText: ::std::os::raw::c_int, + pCtx: *mut ::std::os::raw::c_void, + xToken: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + arg6: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseCount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, + >, + pub xPhraseSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xInstCount: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pnInst: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xInst: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iIdx: ::std::os::raw::c_int, + piPhrase: *mut ::std::os::raw::c_int, + piCol: *mut ::std::os::raw::c_int, + piOff: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: + ::std::option::Option sqlite3_int64>, + pub xColumnText: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pz: *mut *const ::std::os::raw::c_char, + pn: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xColumnSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pnToken: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xQueryPhrase: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + pUserData: *mut ::std::os::raw::c_void, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const Fts5ExtensionApi, + arg2: *mut Fts5Context, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub xSetAuxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pAux: *mut ::std::os::raw::c_void, + xDelete: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub xGetAuxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + bClear: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xPhraseFirst: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + arg2: *mut Fts5PhraseIter, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseNext: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + arg2: *mut Fts5PhraseIter, + piCol: *mut ::std::os::raw::c_int, + piOff: *mut ::std::os::raw::c_int, + ), + >, + pub xPhraseFirstColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + arg2: *mut Fts5PhraseIter, + arg3: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseNextColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + arg2: *mut Fts5PhraseIter, + piCol: *mut ::std::os::raw::c_int, + ), + >, +} +#[test] +fn bindgen_test_layout_Fts5ExtensionApi() { + assert_eq!( + ::std::mem::size_of::(), + 160usize, + concat!("Size of: ", stringify!(Fts5ExtensionApi)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Fts5ExtensionApi)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUserData as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xUserData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnCount as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowCount as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xRowCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xColumnTotalSize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnTotalSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xTokenize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseCount as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseSize as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInstCount as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xInstCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInst as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xInst) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnText as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnText) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnSize as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xQueryPhrase as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xQueryPhrase) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetAuxdata as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xSetAuxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetAuxdata as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xGetAuxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseFirst as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseFirst) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseNext as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseNext) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPhraseFirstColumn as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseFirstColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPhraseNextColumn as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseNextColumn) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5Tokenizer { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct fts5_tokenizer { + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + azArg: *mut *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ppOut: *mut *mut Fts5Tokenizer, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option, + pub xTokenize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Tokenizer, + pCtx: *mut ::std::os::raw::c_void, + flags: ::std::os::raw::c_int, + pText: *const ::std::os::raw::c_char, + nText: ::std::os::raw::c_int, + xToken: ::std::option::Option< + unsafe extern "C" fn( + pCtx: *mut ::std::os::raw::c_void, + tflags: ::std::os::raw::c_int, + pToken: *const ::std::os::raw::c_char, + nToken: ::std::os::raw::c_int, + iStart: ::std::os::raw::c_int, + iEnd: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_fts5_tokenizer() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(fts5_tokenizer)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(fts5_tokenizer)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xTokenize) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct fts5_api { + pub iVersion: ::std::os::raw::c_int, + pub xCreateTokenizer: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + pContext: *mut ::std::os::raw::c_void, + pTokenizer: *mut fts5_tokenizer, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub xFindTokenizer: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + ppContext: *mut *mut ::std::os::raw::c_void, + pTokenizer: *mut fts5_tokenizer, + ) -> ::std::os::raw::c_int, + >, + pub xCreateFunction: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + pContext: *mut ::std::os::raw::c_void, + xFunction: fts5_extension_function, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_fts5_api() { + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(fts5_api)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(fts5_api)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreateTokenizer as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xCreateTokenizer) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindTokenizer as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xFindTokenizer) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreateFunction as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xCreateFunction) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_api_routines { + pub aggregate_context: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub aggregate_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, + >, + pub bind_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_double: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int, + >, + pub bind_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, + ) -> ::std::os::raw::c_int, + >, + pub bind_null: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub bind_parameter_index: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub bind_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub busy_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub busy_timeout: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub changes: + ::std::option::Option ::std::os::raw::c_int>, + pub close: + ::std::option::Option ::std::os::raw::c_int>, + pub collation_needed: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub collation_needed16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub column_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_bytes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_bytes16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub column_database_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_database_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_decltype: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_decltype16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_double: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, + >, + pub column_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_int64: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, + >, + pub column_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_origin_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_origin_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_table_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_table_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar, + >, + pub column_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_type: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value, + >, + pub commit_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub complete: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub complete16: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub create_collation: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_collation16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_function16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_module: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub data_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub db_handle: + ::std::option::Option *mut sqlite3>, + pub declare_vtab: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub enable_shared_cache: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub errmsg: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, + >, + pub errmsg16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, + >, + pub exec: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub expired: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub finalize: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub free: ::std::option::Option, + pub free_table: + ::std::option::Option, + pub get_autocommit: + ::std::option::Option ::std::os::raw::c_int>, + pub get_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub get_table: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub global_recover: ::std::option::Option ::std::os::raw::c_int>, + pub interruptx: ::std::option::Option, + pub last_insert_rowid: + ::std::option::Option sqlite_int64>, + pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, + pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, + pub malloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub mprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub open16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub prepare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub profile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub progress_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ), + >, + pub realloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub result_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_double: + ::std::option::Option, + pub result_error: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_error16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_int64: + ::std::option::Option, + pub result_null: ::std::option::Option, + pub result_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16be: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16le: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_value: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), + >, + pub rollback_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub set_authorizer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub set_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, + ), + >, + pub xsnprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub step: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub table_column_metadata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub thread_cleanup: ::std::option::Option, + pub total_changes: + ::std::option::Option ::std::os::raw::c_int>, + pub trace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub transfer_bindings: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int, + >, + pub update_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub user_data: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, + >, + pub value_blob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_bytes16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_double: ::std::option::Option f64>, + pub value_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_int64: + ::std::option::Option sqlite_int64>, + pub value_numeric_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_text: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, + >, + pub value_text16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16be: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16le: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub vmprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub overload_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub prepare_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub clear_bindings: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub create_module_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_close: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int, + >, + pub blob_read: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_write: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub create_collation_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub file_control: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub memory_highwater: + ::std::option::Option sqlite3_int64>, + pub memory_used: ::std::option::Option sqlite3_int64>, + pub mutex_alloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub mutex_enter: ::std::option::Option, + pub mutex_free: ::std::option::Option, + pub mutex_leave: ::std::option::Option, + pub mutex_try: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub open_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub release_memory: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub result_error_nomem: ::std::option::Option, + pub result_error_toobig: + ::std::option::Option, + pub sleep: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub soft_heap_limit: ::std::option::Option, + pub vfs_find: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, + >, + pub vfs_register: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub vfs_unregister: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, + >, + pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, + pub result_zeroblob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_error_code: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub test_control: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, + >, + pub randomness: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), + >, + pub context_db_handle: + ::std::option::Option *mut sqlite3>, + pub extended_result_codes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub limit: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub next_stmt: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, + >, + pub sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, + >, + pub status: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub backup_finish: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_init: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, + ) -> *mut sqlite3_backup, + >, + pub backup_pagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_remaining: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_step: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub compileoption_get: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, + >, + pub compileoption_used: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub create_function_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub db_config: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int, + >, + pub db_mutex: + ::std::option::Option *mut sqlite3_mutex>, + pub db_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub extended_errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub log: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char, ...), + >, + pub soft_heap_limit64: + ::std::option::Option sqlite3_int64>, + pub sourceid: ::std::option::Option *const ::std::os::raw::c_char>, + pub stmt_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub strnicmp: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub unlock_notify: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub wal_autocheckpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub wal_checkpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub wal_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub blob_reopen: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob, arg2: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub vtab_config: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int, + >, + pub vtab_on_conflict: + ::std::option::Option ::std::os::raw::c_int>, + pub close_v2: + ::std::option::Option ::std::os::raw::c_int>, + pub db_filename: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, + pub db_readonly: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub db_release_memory: + ::std::option::Option ::std::os::raw::c_int>, + pub errstr: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, + >, + pub stmt_busy: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub stmt_readonly: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub stricmp: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub uri_boolean: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub uri_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64, + ) -> sqlite3_int64, + >, + pub uri_parameter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, + pub xvsnprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub wal_checkpoint_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub auto_extension: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_blob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + arg6: ::std::os::raw::c_uchar, + ) -> ::std::os::raw::c_int, + >, + pub cancel_auto_extension: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub load_extension: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub malloc64: ::std::option::Option< + unsafe extern "C" fn(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void, + >, + pub msize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64, + >, + pub realloc64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_uint64, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset_auto_extension: ::std::option::Option, + pub result_blob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + ), + >, + pub result_text64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + arg5: ::std::os::raw::c_uchar, + ), + >, + pub strglob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub value_dup: ::std::option::Option< + unsafe extern "C" fn(arg1: *const sqlite3_value) -> *mut sqlite3_value, + >, + pub value_free: ::std::option::Option, + pub result_zeroblob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: sqlite3_uint64, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_uint64, + ) -> ::std::os::raw::c_int, + >, + pub value_subtype: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint, + >, + pub result_subtype: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint), + >, + pub status64: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut sqlite3_int64, + arg3: *mut sqlite3_int64, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub strlike: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_uint, + ) -> ::std::os::raw::c_int, + >, + pub db_cacheflush: + ::std::option::Option ::std::os::raw::c_int>, + pub system_errno: + ::std::option::Option ::std::os::raw::c_int>, + pub trace_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_uint, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_uint, + arg2: *mut ::std::os::raw::c_void, + arg3: *mut ::std::os::raw::c_void, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub expanded_sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char, + >, + pub set_last_insert_rowid: + ::std::option::Option, + pub prepare_v3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_uint, + arg5: *mut *mut sqlite3_stmt, + arg6: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16_v3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_uint, + arg5: *mut *mut sqlite3_stmt, + arg6: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub bind_pointer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: *const ::std::os::raw::c_char, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub result_pointer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *mut ::std::os::raw::c_void, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::option::Option, + ), + >, + pub value_pointer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_value, + arg2: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub vtab_nochange: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, + >, + pub value_nochange: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub vtab_collation: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_index_info, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub keyword_count: ::std::option::Option ::std::os::raw::c_int>, + pub keyword_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut *const ::std::os::raw::c_char, + arg3: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub keyword_check: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub str_new: + ::std::option::Option *mut sqlite3_str>, + pub str_finish: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char, + >, + pub str_appendf: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_str, zFormat: *const ::std::os::raw::c_char, ...), + >, + pub str_vappendf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_str, + zFormat: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ), + >, + pub str_append: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_str, + zIn: *const ::std::os::raw::c_char, + N: ::std::os::raw::c_int, + ), + >, + pub str_appendall: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_str, zIn: *const ::std::os::raw::c_char), + >, + pub str_appendchar: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_str, + N: ::std::os::raw::c_int, + C: ::std::os::raw::c_char, + ), + >, + pub str_reset: ::std::option::Option, + pub str_errcode: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int, + >, + pub str_length: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int, + >, + pub str_value: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char, + >, + pub create_window_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xValue: ::std::option::Option, + xInv: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub normalized_sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_api_routines() { + assert_eq!( + ::std::mem::size_of::(), + 1928usize, + concat!("Size of: ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_context as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_context) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_count as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_double as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_count as *const _ + as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_index as *const _ + as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_index) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_name as *const _ + as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text16 as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_handler as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_handler) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_timeout as *const _ as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_timeout) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed as *const _ as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_blob as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes as *const _ as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize + }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_count as *const _ as usize + }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name as *const _ + as usize + }, + 184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name16 as *const _ + as usize + }, + 192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype as *const _ as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize + }, + 208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_double as *const _ as usize + }, + 216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, + 224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_int64 as *const _ as usize + }, + 232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name as *const _ as usize + }, + 240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name16 as *const _ as usize + }, + 248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name as *const _ as usize + }, + 256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name16 as *const _ + as usize + }, + 264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name as *const _ as usize + }, + 272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name16 as *const _ + as usize + }, + 280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text as *const _ as usize + }, + 288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text16 as *const _ as usize + }, + 296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_type as *const _ as usize + }, + 304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_type) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_value as *const _ as usize + }, + 312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).commit_hook as *const _ as usize + }, + 320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(commit_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, + 328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, + 336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation as *const _ as usize + }, + 344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation16 as *const _ as usize + }, + 352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function as *const _ as usize + }, + 360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function16 as *const _ as usize + }, + 368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module as *const _ as usize + }, + 376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, + 384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(data_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, + 392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).declare_vtab as *const _ as usize + }, + 400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(declare_vtab) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).enable_shared_cache as *const _ + as usize + }, + 408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(enable_shared_cache) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, + 416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, + 424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, + 432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, + 440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(exec) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, + 448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(expired) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, + 456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(finalize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, + 464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, + 472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_autocommit as *const _ as usize + }, + 480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_autocommit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_auxdata as *const _ as usize + }, + 488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, + 496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).global_recover as *const _ as usize + }, + 504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(global_recover) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, + 512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(interruptx) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize + }, + 520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(last_insert_rowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, + 528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).libversion_number as *const _ as usize + }, + 536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion_number) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, + 544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, + 552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, + 560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, + 568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, + 576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, + 584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, + 592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(profile) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).progress_handler as *const _ as usize + }, + 600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(progress_handler) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, + 608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, + 616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob as *const _ as usize + }, + 624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_double as *const _ as usize + }, + 632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_double) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error as *const _ as usize + }, + 640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error16 as *const _ as usize + }, + 648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, + 656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_int64 as *const _ as usize + }, + 664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_null as *const _ as usize + }, + 672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text as *const _ as usize + }, + 680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16 as *const _ as usize + }, + 688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16be as *const _ as usize + }, + 696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16le as *const _ as usize + }, + 704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16le) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_value as *const _ as usize + }, + 712usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rollback_hook as *const _ as usize + }, + 720usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(rollback_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_authorizer as *const _ as usize + }, + 728usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_authorizer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_auxdata as *const _ as usize + }, + 736usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xsnprintf as *const _ as usize }, + 744usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xsnprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, + 752usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).table_column_metadata as *const _ + as usize + }, + 760usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(table_column_metadata) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize + }, + 768usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(thread_cleanup) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).total_changes as *const _ as usize + }, + 776usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(total_changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, + 784usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(trace) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize + }, + 792usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(transfer_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).update_hook as *const _ as usize + }, + 800usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(update_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, + 808usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(user_data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, + 816usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes as *const _ as usize + }, + 824usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize + }, + 832usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_double as *const _ as usize + }, + 840usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, + 848usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_int64 as *const _ as usize + }, + 856usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize + }, + 864usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_numeric_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, + 872usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16 as *const _ as usize + }, + 880usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16be as *const _ as usize + }, + 888usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16le as *const _ as usize + }, + 896usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16le) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, + 904usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, + 912usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vmprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).overload_function as *const _ as usize + }, + 920usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(overload_function) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, + 928usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize + }, + 936usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).clear_bindings as *const _ as usize + }, + 944usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(clear_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize + }, + 952usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize + }, + 960usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, + 968usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_bytes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, + 976usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_close) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, + 984usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, + 992usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_read) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, + 1000usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_write) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation_v2 as *const _ + as usize + }, + 1008usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).file_control as *const _ as usize + }, + 1016usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(file_control) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_highwater as *const _ as usize + }, + 1024usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_highwater) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_used as *const _ as usize + }, + 1032usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize + }, + 1040usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_alloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_enter as *const _ as usize + }, + 1048usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_enter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, + 1056usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_leave as *const _ as usize + }, + 1064usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_leave) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, + 1072usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_try) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, + 1080usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).release_memory as *const _ as usize + }, + 1088usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(release_memory) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize + }, + 1096usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_nomem) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_toobig as *const _ + as usize + }, + 1104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_toobig) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, + 1112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sleep) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize + }, + 1120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, + 1128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_find) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_register as *const _ as usize + }, + 1136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_register) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize + }, + 1144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_unregister) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize + }, + 1152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xthreadsafe) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize + }, + 1160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_code as *const _ as usize + }, + 1168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_code) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).test_control as *const _ as usize + }, + 1176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(test_control) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, + 1184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(randomness) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).context_db_handle as *const _ as usize + }, + 1192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(context_db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_result_codes as *const _ + as usize + }, + 1200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_result_codes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, + 1208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, + 1216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(next_stmt) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, + 1224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sql) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, + 1232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_finish as *const _ as usize + }, + 1240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_finish) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_init as *const _ as usize + }, + 1248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_init) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_pagecount as *const _ as usize + }, + 1256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_pagecount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_remaining as *const _ as usize + }, + 1264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_remaining) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_step as *const _ as usize + }, + 1272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_get as *const _ as usize + }, + 1280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_get) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_used as *const _ as usize + }, + 1288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function_v2 as *const _ as usize + }, + 1296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function_v2) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_config as *const _ as usize }, + 1304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_config) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_mutex as *const _ as usize }, + 1312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_mutex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_status as *const _ as usize }, + 1320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_errcode as *const _ as usize + }, + 1328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).log as *const _ as usize }, + 1336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(log) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit64 as *const _ as usize + }, + 1344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sourceid as *const _ as usize }, + 1352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sourceid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stmt_status as *const _ as usize + }, + 1360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_status) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strnicmp as *const _ as usize }, + 1368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strnicmp) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).unlock_notify as *const _ as usize + }, + 1376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(unlock_notify) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_autocheckpoint as *const _ as usize + }, + 1384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_autocheckpoint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_checkpoint as *const _ as usize + }, + 1392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_checkpoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).wal_hook as *const _ as usize }, + 1400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).blob_reopen as *const _ as usize + }, + 1408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_reopen) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_config as *const _ as usize + }, + 1416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_config) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_on_conflict as *const _ as usize + }, + 1424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_on_conflict) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close_v2 as *const _ as usize }, + 1432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_filename as *const _ as usize + }, + 1440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_filename) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_readonly as *const _ as usize + }, + 1448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_readonly) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_release_memory as *const _ as usize + }, + 1456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_release_memory) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errstr as *const _ as usize }, + 1464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errstr) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).stmt_busy as *const _ as usize }, + 1472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_busy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stmt_readonly as *const _ as usize + }, + 1480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_readonly) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).stricmp as *const _ as usize }, + 1488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stricmp) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).uri_boolean as *const _ as usize + }, + 1496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_boolean) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).uri_int64 as *const _ as usize }, + 1504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).uri_parameter as *const _ as usize + }, + 1512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_parameter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xvsnprintf as *const _ as usize }, + 1520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xvsnprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_checkpoint_v2 as *const _ as usize + }, + 1528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_checkpoint_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).auto_extension as *const _ as usize + }, + 1536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(auto_extension) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_blob64 as *const _ as usize + }, + 1544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text64 as *const _ as usize + }, + 1552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).cancel_auto_extension as *const _ + as usize + }, + 1560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(cancel_auto_extension) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).load_extension as *const _ as usize + }, + 1568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(load_extension) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc64 as *const _ as usize }, + 1576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).msize as *const _ as usize }, + 1584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(msize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc64 as *const _ as usize }, + 1592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).reset_auto_extension as *const _ + as usize + }, + 1600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset_auto_extension) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob64 as *const _ as usize + }, + 1608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text64 as *const _ as usize + }, + 1616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strglob as *const _ as usize }, + 1624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strglob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_dup as *const _ as usize }, + 1632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_dup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_free as *const _ as usize }, + 1640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob64 as *const _ as usize + }, + 1648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob64 as *const _ as usize + }, + 1656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_subtype as *const _ as usize + }, + 1664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_subtype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_subtype as *const _ as usize + }, + 1672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_subtype) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status64 as *const _ as usize }, + 1680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strlike as *const _ as usize }, + 1688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strlike) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_cacheflush as *const _ as usize + }, + 1696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_cacheflush) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).system_errno as *const _ as usize + }, + 1704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(system_errno) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).trace_v2 as *const _ as usize }, + 1712usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(trace_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).expanded_sql as *const _ as usize + }, + 1720usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(expanded_sql) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_last_insert_rowid as *const _ + as usize + }, + 1728usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_last_insert_rowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare_v3 as *const _ as usize }, + 1736usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare_v3) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).prepare16_v3 as *const _ as usize + }, + 1744usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16_v3) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_pointer as *const _ as usize + }, + 1752usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_pointer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_pointer as *const _ as usize + }, + 1760usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_pointer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_pointer as *const _ as usize + }, + 1768usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_pointer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_nochange as *const _ as usize + }, + 1776usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_nochange) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_nochange as *const _ as usize + }, + 1784usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_nochange) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_collation as *const _ as usize + }, + 1792usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_collation) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).keyword_count as *const _ as usize + }, + 1800usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(keyword_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).keyword_name as *const _ as usize + }, + 1808usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(keyword_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).keyword_check as *const _ as usize + }, + 1816usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(keyword_check) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).str_new as *const _ as usize }, + 1824usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_new) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).str_finish as *const _ as usize }, + 1832usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_finish) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).str_appendf as *const _ as usize + }, + 1840usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_appendf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).str_vappendf as *const _ as usize + }, + 1848usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_vappendf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).str_append as *const _ as usize }, + 1856usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_append) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).str_appendall as *const _ as usize + }, + 1864usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_appendall) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).str_appendchar as *const _ as usize + }, + 1872usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_appendchar) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).str_reset as *const _ as usize }, + 1880usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_reset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).str_errcode as *const _ as usize + }, + 1888usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).str_length as *const _ as usize }, + 1896usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_length) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).str_value as *const _ as usize }, + 1904usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_window_function as *const _ + as usize + }, + 1912usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_window_function) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).normalized_sql as *const _ as usize + }, + 1920usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(normalized_sql) + ) + ); +} +pub type sqlite3_loadext_entry = ::std::option::Option< + unsafe extern "C" fn( + db: *mut sqlite3, + pzErrMsg: *mut *mut ::std::os::raw::c_char, + pThunk: *const sqlite3_api_routines, + ) -> ::std::os::raw::c_int, +>; +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} + +// bindings were built with (non-embedded) loadable_extension: +// we define our own sqlite_api static variable and export it +// to C +#[no_mangle] +pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_routines; + +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) + +pub unsafe fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_context.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_context", + " function" + )))(arg1, nBytes) +} + +pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_double", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_null", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_index.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_index", + " function" + )))(arg1, zName) +} + +pub unsafe fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_value", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_handler", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_timeout.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_timeout", + " function" + )))(arg1, ms) +} + +pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_blob", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype", + " function" + )))(arg1, i) +} + +pub unsafe fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_double", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int64", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_type", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_value", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).commit_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "commit_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete16", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_create_collation( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_collation16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_function( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_function16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function16", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_module( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).data_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "data_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).declare_vtab.expect(stringify!( + "sqlite3_api contains null pointer for ", + "declare_vtab", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).enable_shared_cache.expect(stringify!( + "sqlite3_api contains null pointer for ", + "enable_shared_cache", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errcode", + " function" + )))(db) +} + +pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_exec( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).exec.expect(stringify!( + "sqlite3_api contains null pointer for ", + "exec", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).expired.expect(stringify!( + "sqlite3_api contains null pointer for ", + "expired", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).finalize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "finalize", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free_table", + " function" + )))(result) +} + +pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_autocommit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_autocommit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_auxdata", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_get_table( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_table", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).global_recover.expect(stringify!( + "sqlite3_api contains null pointer for ", + "global_recover", + " function" + )))() +} + +pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).interruptx.expect(stringify!( + "sqlite3_api contains null pointer for ", + "interruptx", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).last_insert_rowid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "last_insert_rowid", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion", + " function" + )))() +} + +pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion_number.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion_number", + " function" + )))() +} + +pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mprintf( + arg1: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mprintf", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_open( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_open16( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_prepare( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_profile( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).profile.expect(stringify!( + "sqlite3_api contains null pointer for ", + "profile", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).progress_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "progress_handler", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_double", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_null", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16be", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16le", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_value", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).rollback_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "rollback_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_authorizer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_authorizer", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_auxdata", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_xsnprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xsnprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xsnprintf", + " function" + )))(arg1, arg2, arg3, vararg1) +} + +pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "step", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_table_column_metadata( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).table_column_metadata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "table_column_metadata", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) +} + +pub unsafe fn sqlite3_thread_cleanup() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).thread_cleanup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "thread_cleanup", + " function" + )))() +} + +pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).total_changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "total_changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).trace.expect(stringify!( + "sqlite3_api contains null pointer for ", + "trace", + " function" + )))(arg1, xTrace, arg2) +} + +pub unsafe fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).transfer_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "transfer_bindings", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).update_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "update_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).user_data.expect(stringify!( + "sqlite3_api contains null pointer for ", + "user_data", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_blob", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_double", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_numeric_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_numeric_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16be", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16le", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vmprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vmprintf", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).overload_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "overload_function", + " function" + )))(arg1, zFuncName, nArg) +} + +pub unsafe fn sqlite3_prepare_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).clear_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "clear_bindings", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_module_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module_v2", + " function" + )))(arg1, arg2, arg3, arg4, xDestroy) +} + +pub unsafe fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_open( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_open", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) +} + +pub unsafe fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_read.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_read", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_write.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_write", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_file_control( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).file_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "file_control", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_highwater.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_highwater", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_used", + " function" + )))() +} + +pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_alloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_alloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_enter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_enter", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_leave.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_leave", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_try.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_try", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_open_v2( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open_v2", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_nomem.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_nomem", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_toobig.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_toobig", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sleep.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sleep", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_find.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_find", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_register.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_register", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_unregister.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_unregister", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xthreadsafe.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xthreadsafe", + " function" + )))() +} + +pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_code.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_code", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_test_control( + arg1: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).test_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "test_control", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).randomness.expect(stringify!( + "sqlite3_api contains null pointer for ", + "randomness", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).context_db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "context_db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_result_codes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_result_codes", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_limit( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "limit", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).next_stmt.expect(stringify!( + "sqlite3_api contains null pointer for ", + "next_stmt", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_status( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_finish.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_finish", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_init( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, +) -> *mut sqlite3_backup { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_init.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_init", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_pagecount.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_pagecount", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_remaining.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_remaining", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_step( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_step", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_compileoption_get( + arg1: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_get.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_get", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_compileoption_used( + arg1: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_used", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_function_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal, xDestroy) +} + +pub unsafe fn sqlite3_db_config( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, + vararg2: &mut i32, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_config", + " function" + )))(arg1, arg2, vararg1, vararg2) +} + +pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_mutex.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_mutex", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_db_status( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_status", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_errcode", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_log( + arg1: ::std::os::raw::c_int, + arg2: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).log.expect(stringify!( + "sqlite3_api contains null pointer for ", + "log", + " function" + )))(arg1, arg2, vararg1) +} + +pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sourceid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sourceid", + " function" + )))() +} + +pub unsafe fn sqlite3_stmt_status( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_status", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_strnicmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strnicmp.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strnicmp", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_unlock_notify( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int), + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).unlock_notify.expect(stringify!( + "sqlite3_api contains null pointer for ", + "unlock_notify", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_wal_autocheckpoint( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_autocheckpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_checkpoint( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_checkpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_checkpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_reopen( + arg1: *mut sqlite3_blob, + arg2: sqlite3_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_reopen.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_reopen", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vtab_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_config", + " function" + )))(arg1, op, vararg1) +} + +pub unsafe fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_on_conflict.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_on_conflict", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close_v2", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_db_filename( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_filename.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_filename", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_db_readonly( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_readonly.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_readonly", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errstr.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errstr", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_busy.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_busy", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stmt_readonly(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_readonly.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_readonly", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stricmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stricmp.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stricmp", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_uri_boolean( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_boolean.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_boolean", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_uri_int64( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64, +) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_uri_parameter( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_parameter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_parameter", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_xvsnprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xvsnprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xvsnprintf", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_wal_checkpoint_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_checkpoint_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_checkpoint_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_auto_extension( + arg1: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).auto_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "auto_extension", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob64", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_text64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + arg6: ::std::os::raw::c_uchar, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text64", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_cancel_auto_extension( + arg1: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).cancel_auto_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "cancel_auto_extension", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_load_extension( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).load_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "load_extension", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_malloc64(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_msize(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).msize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "msize", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_realloc64( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_uint64, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset_auto_extension() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset_auto_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset_auto_extension", + " function" + )))() +} + +pub unsafe fn sqlite3_result_blob64( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob64", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text64( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + arg5: ::std::os::raw::c_uchar, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text64", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_strglob( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strglob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strglob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_value_dup(arg1: *const sqlite3_value) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_dup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_dup", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_free(arg1: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_zeroblob64( + arg1: *mut sqlite3_context, + arg2: sqlite3_uint64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_zeroblob64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_uint64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_value_subtype(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_subtype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_subtype", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_subtype(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_subtype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_subtype", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_status64( + arg1: ::std::os::raw::c_int, + arg2: *mut sqlite3_int64, + arg3: *mut sqlite3_int64, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status64", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_strlike( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_uint, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strlike.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strlike", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_db_cacheflush(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_cacheflush.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_cacheflush", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_system_errno(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).system_errno.expect(stringify!( + "sqlite3_api contains null pointer for ", + "system_errno", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_trace_v2( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_uint, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_uint, + arg2: *mut ::std::os::raw::c_void, + arg3: *mut ::std::os::raw::c_void, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).trace_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "trace_v2", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_expanded_sql(arg1: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).expanded_sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "expanded_sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_set_last_insert_rowid(arg1: *mut sqlite3, arg2: sqlite3_int64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_last_insert_rowid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_last_insert_rowid", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_prepare_v3( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_uint, + arg5: *mut *mut sqlite3_stmt, + arg6: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare_v3.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare_v3", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_prepare16_v3( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_uint, + arg5: *mut *mut sqlite3_stmt, + arg6: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16_v3.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16_v3", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_bind_pointer( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: *const ::std::os::raw::c_char, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_pointer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_pointer", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_result_pointer( + arg1: *mut sqlite3_context, + arg2: *mut ::std::os::raw::c_void, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_pointer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_pointer", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_value_pointer( + arg1: *mut sqlite3_value, + arg2: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_pointer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_pointer", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vtab_nochange(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_nochange.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_nochange", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_nochange(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_nochange.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_nochange", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vtab_collation( + arg1: *mut sqlite3_index_info, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_collation.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_collation", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_keyword_count() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).keyword_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "keyword_count", + " function" + )))() +} + +pub unsafe fn sqlite3_keyword_name( + arg1: ::std::os::raw::c_int, + arg2: *mut *const ::std::os::raw::c_char, + arg3: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).keyword_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "keyword_name", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_keyword_check( + arg1: *const ::std::os::raw::c_char, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).keyword_check.expect(stringify!( + "sqlite3_api contains null pointer for ", + "keyword_check", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_str_new(arg1: *mut sqlite3) -> *mut sqlite3_str { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_new.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_new", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_str_finish(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_finish.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_finish", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_str_appendf( + arg1: *mut sqlite3_str, + zFormat: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_appendf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_appendf", + " function" + )))(arg1, zFormat, vararg1) +} + +pub unsafe fn sqlite3_str_vappendf( + arg1: *mut sqlite3_str, + zFormat: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_vappendf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_vappendf", + " function" + )))(arg1, zFormat, arg2) +} + +pub unsafe fn sqlite3_str_append( + arg1: *mut sqlite3_str, + zIn: *const ::std::os::raw::c_char, + N: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_append.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_append", + " function" + )))(arg1, zIn, N) +} + +pub unsafe fn sqlite3_str_appendall(arg1: *mut sqlite3_str, zIn: *const ::std::os::raw::c_char) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_appendall.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_appendall", + " function" + )))(arg1, zIn) +} + +pub unsafe fn sqlite3_str_appendchar( + arg1: *mut sqlite3_str, + N: ::std::os::raw::c_int, + C: ::std::os::raw::c_char, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_appendchar.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_appendchar", + " function" + )))(arg1, N, C) +} + +pub unsafe fn sqlite3_str_reset(arg1: *mut sqlite3_str) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_reset.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_reset", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_str_errcode(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_errcode", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_str_length(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_length.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_length", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_str_value(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_value", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_window_function( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xValue: ::std::option::Option, + xInv: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_window_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_window_function", + " function" + )))( + arg1, arg2, arg3, arg4, arg5, xStep, xFinal, xValue, xInv, xDestroy, + ) +} + +pub unsafe fn sqlite3_normalized_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).normalized_sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "normalized_sql", + " function" + )))(arg1) +} diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.26.0.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.26.0.rs new file mode 100644 index 000000000..95fe191fe --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.26.0.rs @@ -0,0 +1,5225 @@ +/* automatically generated by rust-bindgen */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.26.0\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3026000; +pub const SQLITE_SOURCE_ID: &'static [u8; 85usize] = + b"2018-12-01 12:34:55 bf8c1b2b7a5960c282e543b9c293686dccff272512d08865f4600fb58238b4f9\0"; +pub const SQLITE_OK: i32 = 0; +pub const SQLITE_ERROR: i32 = 1; +pub const SQLITE_INTERNAL: i32 = 2; +pub const SQLITE_PERM: i32 = 3; +pub const SQLITE_ABORT: i32 = 4; +pub const SQLITE_BUSY: i32 = 5; +pub const SQLITE_LOCKED: i32 = 6; +pub const SQLITE_NOMEM: i32 = 7; +pub const SQLITE_READONLY: i32 = 8; +pub const SQLITE_INTERRUPT: i32 = 9; +pub const SQLITE_IOERR: i32 = 10; +pub const SQLITE_CORRUPT: i32 = 11; +pub const SQLITE_NOTFOUND: i32 = 12; +pub const SQLITE_FULL: i32 = 13; +pub const SQLITE_CANTOPEN: i32 = 14; +pub const SQLITE_PROTOCOL: i32 = 15; +pub const SQLITE_EMPTY: i32 = 16; +pub const SQLITE_SCHEMA: i32 = 17; +pub const SQLITE_TOOBIG: i32 = 18; +pub const SQLITE_CONSTRAINT: i32 = 19; +pub const SQLITE_MISMATCH: i32 = 20; +pub const SQLITE_MISUSE: i32 = 21; +pub const SQLITE_NOLFS: i32 = 22; +pub const SQLITE_AUTH: i32 = 23; +pub const SQLITE_FORMAT: i32 = 24; +pub const SQLITE_RANGE: i32 = 25; +pub const SQLITE_NOTADB: i32 = 26; +pub const SQLITE_NOTICE: i32 = 27; +pub const SQLITE_WARNING: i32 = 28; +pub const SQLITE_ROW: i32 = 100; +pub const SQLITE_DONE: i32 = 101; +pub const SQLITE_ERROR_MISSING_COLLSEQ: i32 = 257; +pub const SQLITE_ERROR_RETRY: i32 = 513; +pub const SQLITE_ERROR_SNAPSHOT: i32 = 769; +pub const SQLITE_IOERR_READ: i32 = 266; +pub const SQLITE_IOERR_SHORT_READ: i32 = 522; +pub const SQLITE_IOERR_WRITE: i32 = 778; +pub const SQLITE_IOERR_FSYNC: i32 = 1034; +pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; +pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; +pub const SQLITE_IOERR_FSTAT: i32 = 1802; +pub const SQLITE_IOERR_UNLOCK: i32 = 2058; +pub const SQLITE_IOERR_RDLOCK: i32 = 2314; +pub const SQLITE_IOERR_DELETE: i32 = 2570; +pub const SQLITE_IOERR_BLOCKED: i32 = 2826; +pub const SQLITE_IOERR_NOMEM: i32 = 3082; +pub const SQLITE_IOERR_ACCESS: i32 = 3338; +pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; +pub const SQLITE_IOERR_LOCK: i32 = 3850; +pub const SQLITE_IOERR_CLOSE: i32 = 4106; +pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; +pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; +pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; +pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; +pub const SQLITE_IOERR_SHMMAP: i32 = 5386; +pub const SQLITE_IOERR_SEEK: i32 = 5642; +pub const SQLITE_IOERR_DELETE_NOENT: i32 = 5898; +pub const SQLITE_IOERR_MMAP: i32 = 6154; +pub const SQLITE_IOERR_GETTEMPPATH: i32 = 6410; +pub const SQLITE_IOERR_CONVPATH: i32 = 6666; +pub const SQLITE_IOERR_VNODE: i32 = 6922; +pub const SQLITE_IOERR_AUTH: i32 = 7178; +pub const SQLITE_IOERR_BEGIN_ATOMIC: i32 = 7434; +pub const SQLITE_IOERR_COMMIT_ATOMIC: i32 = 7690; +pub const SQLITE_IOERR_ROLLBACK_ATOMIC: i32 = 7946; +pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; +pub const SQLITE_LOCKED_VTAB: i32 = 518; +pub const SQLITE_BUSY_RECOVERY: i32 = 261; +pub const SQLITE_BUSY_SNAPSHOT: i32 = 517; +pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; +pub const SQLITE_CANTOPEN_ISDIR: i32 = 526; +pub const SQLITE_CANTOPEN_FULLPATH: i32 = 782; +pub const SQLITE_CANTOPEN_CONVPATH: i32 = 1038; +pub const SQLITE_CANTOPEN_DIRTYWAL: i32 = 1294; +pub const SQLITE_CORRUPT_VTAB: i32 = 267; +pub const SQLITE_CORRUPT_SEQUENCE: i32 = 523; +pub const SQLITE_READONLY_RECOVERY: i32 = 264; +pub const SQLITE_READONLY_CANTLOCK: i32 = 520; +pub const SQLITE_READONLY_ROLLBACK: i32 = 776; +pub const SQLITE_READONLY_DBMOVED: i32 = 1032; +pub const SQLITE_READONLY_CANTINIT: i32 = 1288; +pub const SQLITE_READONLY_DIRECTORY: i32 = 1544; +pub const SQLITE_ABORT_ROLLBACK: i32 = 516; +pub const SQLITE_CONSTRAINT_CHECK: i32 = 275; +pub const SQLITE_CONSTRAINT_COMMITHOOK: i32 = 531; +pub const SQLITE_CONSTRAINT_FOREIGNKEY: i32 = 787; +pub const SQLITE_CONSTRAINT_FUNCTION: i32 = 1043; +pub const SQLITE_CONSTRAINT_NOTNULL: i32 = 1299; +pub const SQLITE_CONSTRAINT_PRIMARYKEY: i32 = 1555; +pub const SQLITE_CONSTRAINT_TRIGGER: i32 = 1811; +pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067; +pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323; +pub const SQLITE_CONSTRAINT_ROWID: i32 = 2579; +pub const SQLITE_NOTICE_RECOVER_WAL: i32 = 283; +pub const SQLITE_NOTICE_RECOVER_ROLLBACK: i32 = 539; +pub const SQLITE_WARNING_AUTOINDEX: i32 = 284; +pub const SQLITE_AUTH_USER: i32 = 279; +pub const SQLITE_OK_LOAD_PERMANENTLY: i32 = 256; +pub const SQLITE_OPEN_READONLY: i32 = 1; +pub const SQLITE_OPEN_READWRITE: i32 = 2; +pub const SQLITE_OPEN_CREATE: i32 = 4; +pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; +pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; +pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; +pub const SQLITE_OPEN_URI: i32 = 64; +pub const SQLITE_OPEN_MEMORY: i32 = 128; +pub const SQLITE_OPEN_MAIN_DB: i32 = 256; +pub const SQLITE_OPEN_TEMP_DB: i32 = 512; +pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; +pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; +pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; +pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; +pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; +pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; +pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; +pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; +pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; +pub const SQLITE_OPEN_WAL: i32 = 524288; +pub const SQLITE_IOCAP_ATOMIC: i32 = 1; +pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; +pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; +pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; +pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; +pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; +pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; +pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; +pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; +pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; +pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; +pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; +pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE: i32 = 4096; +pub const SQLITE_IOCAP_IMMUTABLE: i32 = 8192; +pub const SQLITE_IOCAP_BATCH_ATOMIC: i32 = 16384; +pub const SQLITE_LOCK_NONE: i32 = 0; +pub const SQLITE_LOCK_SHARED: i32 = 1; +pub const SQLITE_LOCK_RESERVED: i32 = 2; +pub const SQLITE_LOCK_PENDING: i32 = 3; +pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; +pub const SQLITE_SYNC_NORMAL: i32 = 2; +pub const SQLITE_SYNC_FULL: i32 = 3; +pub const SQLITE_SYNC_DATAONLY: i32 = 16; +pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; +pub const SQLITE_FCNTL_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_FCNTL_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_FCNTL_LAST_ERRNO: i32 = 4; +pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; +pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; +pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; +pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; +pub const SQLITE_FCNTL_WIN32_AV_RETRY: i32 = 9; +pub const SQLITE_FCNTL_PERSIST_WAL: i32 = 10; +pub const SQLITE_FCNTL_OVERWRITE: i32 = 11; +pub const SQLITE_FCNTL_VFSNAME: i32 = 12; +pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE: i32 = 13; +pub const SQLITE_FCNTL_PRAGMA: i32 = 14; +pub const SQLITE_FCNTL_BUSYHANDLER: i32 = 15; +pub const SQLITE_FCNTL_TEMPFILENAME: i32 = 16; +pub const SQLITE_FCNTL_MMAP_SIZE: i32 = 18; +pub const SQLITE_FCNTL_TRACE: i32 = 19; +pub const SQLITE_FCNTL_HAS_MOVED: i32 = 20; +pub const SQLITE_FCNTL_SYNC: i32 = 21; +pub const SQLITE_FCNTL_COMMIT_PHASETWO: i32 = 22; +pub const SQLITE_FCNTL_WIN32_SET_HANDLE: i32 = 23; +pub const SQLITE_FCNTL_WAL_BLOCK: i32 = 24; +pub const SQLITE_FCNTL_ZIPVFS: i32 = 25; +pub const SQLITE_FCNTL_RBU: i32 = 26; +pub const SQLITE_FCNTL_VFS_POINTER: i32 = 27; +pub const SQLITE_FCNTL_JOURNAL_POINTER: i32 = 28; +pub const SQLITE_FCNTL_WIN32_GET_HANDLE: i32 = 29; +pub const SQLITE_FCNTL_PDB: i32 = 30; +pub const SQLITE_FCNTL_BEGIN_ATOMIC_WRITE: i32 = 31; +pub const SQLITE_FCNTL_COMMIT_ATOMIC_WRITE: i32 = 32; +pub const SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE: i32 = 33; +pub const SQLITE_FCNTL_LOCK_TIMEOUT: i32 = 34; +pub const SQLITE_FCNTL_DATA_VERSION: i32 = 35; +pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_LAST_ERRNO: i32 = 4; +pub const SQLITE_ACCESS_EXISTS: i32 = 0; +pub const SQLITE_ACCESS_READWRITE: i32 = 1; +pub const SQLITE_ACCESS_READ: i32 = 2; +pub const SQLITE_SHM_UNLOCK: i32 = 1; +pub const SQLITE_SHM_LOCK: i32 = 2; +pub const SQLITE_SHM_SHARED: i32 = 4; +pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; +pub const SQLITE_SHM_NLOCK: i32 = 8; +pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; +pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; +pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; +pub const SQLITE_CONFIG_MALLOC: i32 = 4; +pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; +pub const SQLITE_CONFIG_SCRATCH: i32 = 6; +pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; +pub const SQLITE_CONFIG_HEAP: i32 = 8; +pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; +pub const SQLITE_CONFIG_MUTEX: i32 = 10; +pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; +pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; +pub const SQLITE_CONFIG_PCACHE: i32 = 14; +pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; +pub const SQLITE_CONFIG_LOG: i32 = 16; +pub const SQLITE_CONFIG_URI: i32 = 17; +pub const SQLITE_CONFIG_PCACHE2: i32 = 18; +pub const SQLITE_CONFIG_GETPCACHE2: i32 = 19; +pub const SQLITE_CONFIG_COVERING_INDEX_SCAN: i32 = 20; +pub const SQLITE_CONFIG_SQLLOG: i32 = 21; +pub const SQLITE_CONFIG_MMAP_SIZE: i32 = 22; +pub const SQLITE_CONFIG_WIN32_HEAPSIZE: i32 = 23; +pub const SQLITE_CONFIG_PCACHE_HDRSZ: i32 = 24; +pub const SQLITE_CONFIG_PMASZ: i32 = 25; +pub const SQLITE_CONFIG_STMTJRNL_SPILL: i32 = 26; +pub const SQLITE_CONFIG_SMALL_MALLOC: i32 = 27; +pub const SQLITE_CONFIG_SORTERREF_SIZE: i32 = 28; +pub const SQLITE_DBCONFIG_MAINDBNAME: i32 = 1000; +pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; +pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; +pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; +pub const SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: i32 = 1004; +pub const SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: i32 = 1005; +pub const SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE: i32 = 1006; +pub const SQLITE_DBCONFIG_ENABLE_QPSG: i32 = 1007; +pub const SQLITE_DBCONFIG_TRIGGER_EQP: i32 = 1008; +pub const SQLITE_DBCONFIG_RESET_DATABASE: i32 = 1009; +pub const SQLITE_DBCONFIG_DEFENSIVE: i32 = 1010; +pub const SQLITE_DBCONFIG_MAX: i32 = 1010; +pub const SQLITE_DENY: i32 = 1; +pub const SQLITE_IGNORE: i32 = 2; +pub const SQLITE_CREATE_INDEX: i32 = 1; +pub const SQLITE_CREATE_TABLE: i32 = 2; +pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; +pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; +pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; +pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; +pub const SQLITE_CREATE_TRIGGER: i32 = 7; +pub const SQLITE_CREATE_VIEW: i32 = 8; +pub const SQLITE_DELETE: i32 = 9; +pub const SQLITE_DROP_INDEX: i32 = 10; +pub const SQLITE_DROP_TABLE: i32 = 11; +pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; +pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; +pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; +pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; +pub const SQLITE_DROP_TRIGGER: i32 = 16; +pub const SQLITE_DROP_VIEW: i32 = 17; +pub const SQLITE_INSERT: i32 = 18; +pub const SQLITE_PRAGMA: i32 = 19; +pub const SQLITE_READ: i32 = 20; +pub const SQLITE_SELECT: i32 = 21; +pub const SQLITE_TRANSACTION: i32 = 22; +pub const SQLITE_UPDATE: i32 = 23; +pub const SQLITE_ATTACH: i32 = 24; +pub const SQLITE_DETACH: i32 = 25; +pub const SQLITE_ALTER_TABLE: i32 = 26; +pub const SQLITE_REINDEX: i32 = 27; +pub const SQLITE_ANALYZE: i32 = 28; +pub const SQLITE_CREATE_VTABLE: i32 = 29; +pub const SQLITE_DROP_VTABLE: i32 = 30; +pub const SQLITE_FUNCTION: i32 = 31; +pub const SQLITE_SAVEPOINT: i32 = 32; +pub const SQLITE_COPY: i32 = 0; +pub const SQLITE_RECURSIVE: i32 = 33; +pub const SQLITE_TRACE_STMT: i32 = 1; +pub const SQLITE_TRACE_PROFILE: i32 = 2; +pub const SQLITE_TRACE_ROW: i32 = 4; +pub const SQLITE_TRACE_CLOSE: i32 = 8; +pub const SQLITE_LIMIT_LENGTH: i32 = 0; +pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; +pub const SQLITE_LIMIT_COLUMN: i32 = 2; +pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; +pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; +pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; +pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; +pub const SQLITE_LIMIT_ATTACHED: i32 = 7; +pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; +pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; +pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; +pub const SQLITE_LIMIT_WORKER_THREADS: i32 = 11; +pub const SQLITE_PREPARE_PERSISTENT: i32 = 1; +pub const SQLITE_PREPARE_NORMALIZE: i32 = 2; +pub const SQLITE_INTEGER: i32 = 1; +pub const SQLITE_FLOAT: i32 = 2; +pub const SQLITE_BLOB: i32 = 4; +pub const SQLITE_NULL: i32 = 5; +pub const SQLITE_TEXT: i32 = 3; +pub const SQLITE3_TEXT: i32 = 3; +pub const SQLITE_UTF8: i32 = 1; +pub const SQLITE_UTF16LE: i32 = 2; +pub const SQLITE_UTF16BE: i32 = 3; +pub const SQLITE_UTF16: i32 = 4; +pub const SQLITE_ANY: i32 = 5; +pub const SQLITE_UTF16_ALIGNED: i32 = 8; +pub const SQLITE_DETERMINISTIC: i32 = 2048; +pub const SQLITE_WIN32_DATA_DIRECTORY_TYPE: i32 = 1; +pub const SQLITE_WIN32_TEMP_DIRECTORY_TYPE: i32 = 2; +pub const SQLITE_INDEX_SCAN_UNIQUE: i32 = 1; +pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; +pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; +pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; +pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; +pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; +pub const SQLITE_INDEX_CONSTRAINT_LIKE: i32 = 65; +pub const SQLITE_INDEX_CONSTRAINT_GLOB: i32 = 66; +pub const SQLITE_INDEX_CONSTRAINT_REGEXP: i32 = 67; +pub const SQLITE_INDEX_CONSTRAINT_NE: i32 = 68; +pub const SQLITE_INDEX_CONSTRAINT_ISNOT: i32 = 69; +pub const SQLITE_INDEX_CONSTRAINT_ISNOTNULL: i32 = 70; +pub const SQLITE_INDEX_CONSTRAINT_ISNULL: i32 = 71; +pub const SQLITE_INDEX_CONSTRAINT_IS: i32 = 72; +pub const SQLITE_INDEX_CONSTRAINT_FUNCTION: i32 = 150; +pub const SQLITE_MUTEX_FAST: i32 = 0; +pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; +pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; +pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; +pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; +pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; +pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; +pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; +pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; +pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; +pub const SQLITE_MUTEX_STATIC_APP1: i32 = 8; +pub const SQLITE_MUTEX_STATIC_APP2: i32 = 9; +pub const SQLITE_MUTEX_STATIC_APP3: i32 = 10; +pub const SQLITE_MUTEX_STATIC_VFS1: i32 = 11; +pub const SQLITE_MUTEX_STATIC_VFS2: i32 = 12; +pub const SQLITE_MUTEX_STATIC_VFS3: i32 = 13; +pub const SQLITE_TESTCTRL_FIRST: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; +pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; +pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; +pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; +pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; +pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; +pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; +pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; +pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; +pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; +pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; +pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 17; +pub const SQLITE_TESTCTRL_INTERNAL_FUNCTIONS: i32 = 17; +pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 18; +pub const SQLITE_TESTCTRL_EXPLAIN_STMT: i32 = 19; +pub const SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD: i32 = 19; +pub const SQLITE_TESTCTRL_NEVER_CORRUPT: i32 = 20; +pub const SQLITE_TESTCTRL_VDBE_COVERAGE: i32 = 21; +pub const SQLITE_TESTCTRL_BYTEORDER: i32 = 22; +pub const SQLITE_TESTCTRL_ISINIT: i32 = 23; +pub const SQLITE_TESTCTRL_SORTER_MMAP: i32 = 24; +pub const SQLITE_TESTCTRL_IMPOSTER: i32 = 25; +pub const SQLITE_TESTCTRL_PARSER_COVERAGE: i32 = 26; +pub const SQLITE_TESTCTRL_LAST: i32 = 26; +pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; +pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; +pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; +pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; +pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; +pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; +pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; +pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; +pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; +pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; +pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; +pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; +pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; +pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; +pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; +pub const SQLITE_DBSTATUS_CACHE_HIT: i32 = 7; +pub const SQLITE_DBSTATUS_CACHE_MISS: i32 = 8; +pub const SQLITE_DBSTATUS_CACHE_WRITE: i32 = 9; +pub const SQLITE_DBSTATUS_DEFERRED_FKS: i32 = 10; +pub const SQLITE_DBSTATUS_CACHE_USED_SHARED: i32 = 11; +pub const SQLITE_DBSTATUS_CACHE_SPILL: i32 = 12; +pub const SQLITE_DBSTATUS_MAX: i32 = 12; +pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; +pub const SQLITE_STMTSTATUS_SORT: i32 = 2; +pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; +pub const SQLITE_STMTSTATUS_VM_STEP: i32 = 4; +pub const SQLITE_STMTSTATUS_REPREPARE: i32 = 5; +pub const SQLITE_STMTSTATUS_RUN: i32 = 6; +pub const SQLITE_STMTSTATUS_MEMUSED: i32 = 99; +pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; +pub const SQLITE_CHECKPOINT_FULL: i32 = 1; +pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; +pub const SQLITE_CHECKPOINT_TRUNCATE: i32 = 3; +pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; +pub const SQLITE_ROLLBACK: i32 = 1; +pub const SQLITE_FAIL: i32 = 3; +pub const SQLITE_REPLACE: i32 = 5; +pub const SQLITE_SCANSTAT_NLOOP: i32 = 0; +pub const SQLITE_SCANSTAT_NVISIT: i32 = 1; +pub const SQLITE_SCANSTAT_EST: i32 = 2; +pub const SQLITE_SCANSTAT_NAME: i32 = 3; +pub const SQLITE_SCANSTAT_EXPLAIN: i32 = 4; +pub const SQLITE_SCANSTAT_SELECTID: i32 = 5; +pub const SQLITE_SERIALIZE_NOCOPY: i32 = 1; +pub const SQLITE_DESERIALIZE_FREEONCLOSE: i32 = 1; +pub const SQLITE_DESERIALIZE_RESIZEABLE: i32 = 2; +pub const SQLITE_DESERIALIZE_READONLY: i32 = 4; +pub const NOT_WITHIN: i32 = 0; +pub const PARTLY_WITHIN: i32 = 1; +pub const FULLY_WITHIN: i32 = 2; +pub const FTS5_TOKENIZE_QUERY: i32 = 1; +pub const FTS5_TOKENIZE_PREFIX: i32 = 2; +pub const FTS5_TOKENIZE_DOCUMENT: i32 = 4; +pub const FTS5_TOKENIZE_AUX: i32 = 8; +pub const FTS5_TOKEN_COLOCATED: i32 = 1; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; +extern "C" { + #[link_name = "\u{1}sqlite3_version"] + pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; +} +extern "C" { + pub fn sqlite3_libversion() -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_sourceid() -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_libversion_number() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_compileoption_used( + zOptName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_compileoption_get(N: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_threadsafe() -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3 { + _unused: [u8; 0], +} +pub type sqlite_int64 = ::std::os::raw::c_longlong; +pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; +pub type sqlite3_int64 = sqlite_int64; +pub type sqlite3_uint64 = sqlite_uint64; +extern "C" { + pub fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +extern "C" { + pub fn sqlite3_exec( + arg1: *mut sqlite3, + sql: *const ::std::os::raw::c_char, + callback: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg2: *mut ::std::os::raw::c_void, + errmsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_file { + pub pMethods: *const sqlite3_io_methods, +} +#[test] +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xShmMap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iPg: ::std::os::raw::c_int, + pgsz: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xShmLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + offset: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xShmBarrier: ::std::option::Option, + pub xShmUnmap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + deleteFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iOfst: sqlite3_int64, + iAmt: ::std::os::raw::c_int, + pp: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xUnfetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iOfst: sqlite3_int64, + p: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 152usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmMap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmBarrier) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmUnmap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnfetch as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnfetch) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_api_routines { + _unused: [u8; 0], +} +pub type sqlite3_syscall_ptr = ::std::option::Option; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vfs { + pub iVersion: ::std::os::raw::c_int, + pub szOsFile: ::std::os::raw::c_int, + pub mxPathname: ::std::os::raw::c_int, + pub pNext: *mut sqlite3_vfs, + pub zName: *const ::std::os::raw::c_char, + pub pAppData: *mut ::std::os::raw::c_void, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTimeInt64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xSetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: sqlite3_syscall_ptr, + ) -> ::std::os::raw::c_int, + >, + pub xGetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> sqlite3_syscall_ptr, + >, + pub xNextSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_vfs() { + assert_eq!( + ::std::mem::size_of::(), + 168usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTimeInt64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xNextSystemCall) + ) + ); +} +extern "C" { + pub fn sqlite3_initialize() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_shutdown() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_os_init() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_os_end() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_db_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mem_methods { + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub pAppData: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_mem_methods() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +extern "C" { + pub fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + onoff: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_set_last_insert_rowid(arg1: *mut sqlite3, arg2: sqlite3_int64); +} +extern "C" { + pub fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_interrupt(arg1: *mut sqlite3); +} +extern "C" { + pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_get_table( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + pazResult: *mut *mut *mut ::std::os::raw::c_char, + pnRow: *mut ::std::os::raw::c_int, + pnColumn: *mut ::std::os::raw::c_int, + pzErrmsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char); +} +extern "C" { + pub fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char, ...) + -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_snprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_vsnprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_malloc64(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_realloc64( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_uint64, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_free(arg1: *mut ::std::os::raw::c_void); +} +extern "C" { + pub fn sqlite3_msize(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64; +} +extern "C" { + pub fn sqlite3_memory_used() -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_randomness(N: ::std::os::raw::c_int, P: *mut ::std::os::raw::c_void); +} +extern "C" { + pub fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + xAuth: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pUserData: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_profile( + arg1: *mut sqlite3, + xProfile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_trace_v2( + arg1: *mut sqlite3, + uMask: ::std::os::raw::c_uint, + xCallback: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_uint, + arg2: *mut ::std::os::raw::c_void, + arg3: *mut ::std::os::raw::c_void, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pCtx: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + pub fn sqlite3_open( + filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_open16( + filename: *const ::std::os::raw::c_void, + ppDb: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_open_v2( + filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3, + flags: ::std::os::raw::c_int, + zVfs: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_uri_parameter( + zFilename: *const ::std::os::raw::c_char, + zParam: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_uri_boolean( + zFile: *const ::std::os::raw::c_char, + zParam: *const ::std::os::raw::c_char, + bDefault: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_uri_int64( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64, + ) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_extended_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_stmt { + _unused: [u8; 0], +} +extern "C" { + pub fn sqlite3_limit( + arg1: *mut sqlite3, + id: ::std::os::raw::c_int, + newVal: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_prepare( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_prepare_v2( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_prepare_v3( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + prepFlags: ::std::os::raw::c_uint, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_prepare16( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_prepare16_v2( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_prepare16_v3( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + prepFlags: ::std::os::raw::c_uint, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_expanded_sql(pStmt: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_normalized_sql(pStmt: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_stmt_readonly(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_value { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_context { + _unused: [u8; 0], +} +extern "C" { + pub fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_blob64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_int64, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_text64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + encoding: ::std::os::raw::c_uchar, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_pointer( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: *const ::std::os::raw::c_char, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_zeroblob64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_uint64, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64; +} +extern "C" { + pub fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar; +} +extern "C" { + pub fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value; +} +extern "C" { + pub fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function16( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_void, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function_v2( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_window_function( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xValue: ::std::option::Option, + xInverse: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_global_recover() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_thread_cleanup(); +} +extern "C" { + pub fn sqlite3_memory_alarm( + arg1: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_int64, + arg3: ::std::os::raw::c_int, + ), + >, + arg2: *mut ::std::os::raw::c_void, + arg3: sqlite3_int64, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64; +} +extern "C" { + pub fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_value_pointer( + arg1: *mut sqlite3_value, + arg2: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar; +} +extern "C" { + pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_nochange(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_subtype(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint; +} +extern "C" { + pub fn sqlite3_value_dup(arg1: *const sqlite3_value) -> *mut sqlite3_value; +} +extern "C" { + pub fn sqlite3_value_free(arg1: *mut sqlite3_value); +} +extern "C" { + pub fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3; +} +extern "C" { + pub fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option, + ); +} +pub type sqlite3_destructor_type = + ::std::option::Option; +extern "C" { + pub fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_blob64( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64); +} +extern "C" { + pub fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context); +} +extern "C" { + pub fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context); +} +extern "C" { + pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite3_int64); +} +extern "C" { + pub fn sqlite3_result_null(arg1: *mut sqlite3_context); +} +extern "C" { + pub fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text64( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + encoding: ::std::os::raw::c_uchar, + ); +} +extern "C" { + pub fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value); +} +extern "C" { + pub fn sqlite3_result_pointer( + arg1: *mut sqlite3_context, + arg2: *mut ::std::os::raw::c_void, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, n: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_result_zeroblob64( + arg1: *mut sqlite3_context, + n: sqlite3_uint64, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_result_subtype(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint); +} +extern "C" { + pub fn sqlite3_create_collation( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation16( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_void, + eTextRep: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "\u{1}sqlite3_temp_directory"] + pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "\u{1}sqlite3_data_directory"] + pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_win32_set_directory( + type_: ::std::os::raw::c_ulong, + zValue: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_win32_set_directory8( + type_: ::std::os::raw::c_ulong, + zValue: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_win32_set_directory16( + type_: ::std::os::raw::c_ulong, + zValue: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3; +} +extern "C" { + pub fn sqlite3_db_filename( + db: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_db_readonly( + db: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) -> *mut sqlite3_stmt; +} +extern "C" { + pub fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_soft_heap_limit64(N: sqlite3_int64) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_soft_heap_limit(N: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_table_column_metadata( + db: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + zTableName: *const ::std::os::raw::c_char, + zColumnName: *const ::std::os::raw::c_char, + pzDataType: *mut *const ::std::os::raw::c_char, + pzCollSeq: *mut *const ::std::os::raw::c_char, + pNotNull: *mut ::std::os::raw::c_int, + pPrimaryKey: *mut ::std::os::raw::c_int, + pAutoinc: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_load_extension( + db: *mut sqlite3, + zFile: *const ::std::os::raw::c_char, + zProc: *const ::std::os::raw::c_char, + pzErrMsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_enable_load_extension( + db: *mut sqlite3, + onoff: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_auto_extension( + xEntryPoint: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_cancel_auto_extension( + xEntryPoint: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_reset_auto_extension(); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSavepoint: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRelease: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRollbackTo: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xShadowName: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 192usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSavepoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRelease) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollbackTo) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShadowName as *const _ as usize }, + 184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xShadowName) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info { + pub nConstraint: ::std::os::raw::c_int, + pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, + pub nOrderBy: ::std::os::raw::c_int, + pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, + pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, + pub idxNum: ::std::os::raw::c_int, + pub idxStr: *mut ::std::os::raw::c_char, + pub needToFreeIdxStr: ::std::os::raw::c_int, + pub orderByConsumed: ::std::os::raw::c_int, + pub estimatedCost: f64, + pub estimatedRows: sqlite3_int64, + pub idxFlags: ::std::os::raw::c_int, + pub colUsed: sqlite3_uint64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint { + pub iColumn: ::std::os::raw::c_int, + pub op: ::std::os::raw::c_uchar, + pub usable: ::std::os::raw::c_uchar, + pub iTermOffset: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_orderby { + pub iColumn: ::std::os::raw::c_int, + pub desc: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint_usage { + pub argvIndex: ::std::os::raw::c_int, + pub omit: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); +} +#[test] +fn bindgen_test_layout_sqlite3_index_info() { + assert_eq!( + ::std::mem::size_of::(), + 96usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedRows as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedRows) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxFlags as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxFlags) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).colUsed as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(colUsed) + ) + ); +} +extern "C" { + pub fn sqlite3_create_module( + db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + p: *const sqlite3_module, + pClientData: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_module_v2( + db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + p: *const sqlite3_module, + pClientData: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +extern "C" { + pub fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + zSQL: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_blob { + _unused: [u8; 0], +} +extern "C" { + pub fn sqlite3_blob_open( + arg1: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + zTable: *const ::std::os::raw::c_char, + zColumn: *const ::std::os::raw::c_char, + iRow: sqlite3_int64, + flags: ::std::os::raw::c_int, + ppBlob: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_blob_reopen( + arg1: *mut sqlite3_blob, + arg2: sqlite3_int64, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + Z: *mut ::std::os::raw::c_void, + N: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + z: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs; +} +extern "C" { + pub fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + makeDflt: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex; +} +extern "C" { + pub fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex); +} +extern "C" { + pub fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex); +} +extern "C" { + pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex_methods { + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_mutex_methods() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +extern "C" { + pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex; +} +extern "C" { + pub fn sqlite3_file_control( + arg1: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + op: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_keyword_count() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_keyword_name( + arg1: ::std::os::raw::c_int, + arg2: *mut *const ::std::os::raw::c_char, + arg3: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_keyword_check( + arg1: *const ::std::os::raw::c_char, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_str { + _unused: [u8; 0], +} +extern "C" { + pub fn sqlite3_str_new(arg1: *mut sqlite3) -> *mut sqlite3_str; +} +extern "C" { + pub fn sqlite3_str_finish(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_str_appendf(arg1: *mut sqlite3_str, zFormat: *const ::std::os::raw::c_char, ...); +} +extern "C" { + pub fn sqlite3_str_vappendf( + arg1: *mut sqlite3_str, + zFormat: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ); +} +extern "C" { + pub fn sqlite3_str_append( + arg1: *mut sqlite3_str, + zIn: *const ::std::os::raw::c_char, + N: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn sqlite3_str_appendall(arg1: *mut sqlite3_str, zIn: *const ::std::os::raw::c_char); +} +extern "C" { + pub fn sqlite3_str_appendchar( + arg1: *mut sqlite3_str, + N: ::std::os::raw::c_int, + C: ::std::os::raw::c_char, + ); +} +extern "C" { + pub fn sqlite3_str_reset(arg1: *mut sqlite3_str); +} +extern "C" { + pub fn sqlite3_str_errcode(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_str_length(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_str_value(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_status( + op: ::std::os::raw::c_int, + pCurrent: *mut ::std::os::raw::c_int, + pHighwater: *mut ::std::os::raw::c_int, + resetFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_status64( + op: ::std::os::raw::c_int, + pCurrent: *mut sqlite3_int64, + pHighwater: *mut sqlite3_int64, + resetFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_db_status( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + pCur: *mut ::std::os::raw::c_int, + pHiwtr: *mut ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_stmt_status( + arg1: *mut sqlite3_stmt, + op: ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_page { + pub pBuf: *mut ::std::os::raw::c_void, + pub pExtra: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_page() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pBuf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pExtra) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods2 { + pub iVersion: ::std::os::raw::c_int, + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + szExtra: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache_page, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, + pub xShrink: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods2() { + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iVersion as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDestroy as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShrink) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods { + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_backup { + _unused: [u8; 0], +} +extern "C" { + pub fn sqlite3_backup_init( + pDest: *mut sqlite3, + zDestName: *const ::std::os::raw::c_char, + pSource: *mut sqlite3, + zSourceName: *const ::std::os::raw::c_char, + ) -> *mut sqlite3_backup; +} +extern "C" { + pub fn sqlite3_backup_step( + p: *mut sqlite3_backup, + nPage: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_backup_finish(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_backup_remaining(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_backup_pagecount(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_unlock_notify( + pBlocked: *mut sqlite3, + xNotify: ::std::option::Option< + unsafe extern "C" fn( + apArg: *mut *mut ::std::os::raw::c_void, + nArg: ::std::os::raw::c_int, + ), + >, + pNotifyArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_stricmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_strnicmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_strglob( + zGlob: *const ::std::os::raw::c_char, + zStr: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_strlike( + zGlob: *const ::std::os::raw::c_char, + zStr: *const ::std::os::raw::c_char, + cEsc: ::std::os::raw::c_uint, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_log( + iErrCode: ::std::os::raw::c_int, + zFormat: *const ::std::os::raw::c_char, + ... + ); +} +extern "C" { + pub fn sqlite3_wal_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_wal_autocheckpoint( + db: *mut sqlite3, + N: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_wal_checkpoint( + db: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_wal_checkpoint_v2( + db: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + eMode: ::std::os::raw::c_int, + pnLog: *mut ::std::os::raw::c_int, + pnCkpt: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_vtab_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_vtab_nochange(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_vtab_collation( + arg1: *mut sqlite3_index_info, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_stmt_scanstatus( + pStmt: *mut sqlite3_stmt, + idx: ::std::os::raw::c_int, + iScanStatusOp: ::std::os::raw::c_int, + pOut: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_stmt_scanstatus_reset(arg1: *mut sqlite3_stmt); +} +extern "C" { + pub fn sqlite3_db_cacheflush(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_system_errno(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct sqlite3_snapshot { + pub hidden: [::std::os::raw::c_uchar; 48usize], +} +#[test] +fn bindgen_test_layout_sqlite3_snapshot() { + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!("Size of: ", stringify!(sqlite3_snapshot)) + ); + assert_eq!( + ::std::mem::align_of::(), + 1usize, + concat!("Alignment of ", stringify!(sqlite3_snapshot)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).hidden as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_snapshot), + "::", + stringify!(hidden) + ) + ); +} +extern "C" { + pub fn sqlite3_snapshot_get( + db: *mut sqlite3, + zSchema: *const ::std::os::raw::c_char, + ppSnapshot: *mut *mut sqlite3_snapshot, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_snapshot_open( + db: *mut sqlite3, + zSchema: *const ::std::os::raw::c_char, + pSnapshot: *mut sqlite3_snapshot, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_snapshot_free(arg1: *mut sqlite3_snapshot); +} +extern "C" { + pub fn sqlite3_snapshot_cmp( + p1: *mut sqlite3_snapshot, + p2: *mut sqlite3_snapshot, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_snapshot_recover( + db: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_serialize( + db: *mut sqlite3, + zSchema: *const ::std::os::raw::c_char, + piSize: *mut sqlite3_int64, + mFlags: ::std::os::raw::c_uint, + ) -> *mut ::std::os::raw::c_uchar; +} +extern "C" { + pub fn sqlite3_deserialize( + db: *mut sqlite3, + zSchema: *const ::std::os::raw::c_char, + pData: *mut ::std::os::raw::c_uchar, + szDb: sqlite3_int64, + szBuf: sqlite3_int64, + mFlags: ::std::os::raw::c_uint, + ) -> ::std::os::raw::c_int; +} +pub type sqlite3_rtree_dbl = f64; +extern "C" { + pub fn sqlite3_rtree_geometry_callback( + db: *mut sqlite3, + zGeom: *const ::std::os::raw::c_char, + xGeom: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_rtree_geometry, + arg2: ::std::os::raw::c_int, + arg3: *mut sqlite3_rtree_dbl, + arg4: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pContext: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_geometry { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut sqlite3_rtree_dbl, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_geometry() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(xDelUser) + ) + ); +} +extern "C" { + pub fn sqlite3_rtree_query_callback( + db: *mut sqlite3, + zQueryFunc: *const ::std::os::raw::c_char, + xQueryFunc: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_rtree_query_info) -> ::std::os::raw::c_int, + >, + pContext: *mut ::std::os::raw::c_void, + xDestructor: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_query_info { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut sqlite3_rtree_dbl, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, + pub aCoord: *mut sqlite3_rtree_dbl, + pub anQueue: *mut ::std::os::raw::c_uint, + pub nCoord: ::std::os::raw::c_int, + pub iLevel: ::std::os::raw::c_int, + pub mxLevel: ::std::os::raw::c_int, + pub iRowid: sqlite3_int64, + pub rParentScore: sqlite3_rtree_dbl, + pub eParentWithin: ::std::os::raw::c_int, + pub eWithin: ::std::os::raw::c_int, + pub rScore: sqlite3_rtree_dbl, + pub apSqlParam: *mut *mut sqlite3_value, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_query_info() { + assert_eq!( + ::std::mem::size_of::(), + 112usize, + concat!("Size of: ", stringify!(sqlite3_rtree_query_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_query_info)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).pContext as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDelUser as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(xDelUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aCoord as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(aCoord) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).anQueue as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(anQueue) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nCoord as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(nCoord) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iLevel as *const _ as usize }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(iLevel) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mxLevel as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(mxLevel) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iRowid as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(iRowid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rParentScore as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(rParentScore) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eParentWithin as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(eParentWithin) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eWithin as *const _ as usize + }, + 92usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(eWithin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).rScore as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(rScore) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).apSqlParam as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(apSqlParam) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5Context { + _unused: [u8; 0], +} +pub type fts5_extension_function = ::std::option::Option< + unsafe extern "C" fn( + pApi: *const Fts5ExtensionApi, + pFts: *mut Fts5Context, + pCtx: *mut sqlite3_context, + nVal: ::std::os::raw::c_int, + apVal: *mut *mut sqlite3_value, + ), +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5PhraseIter { + pub a: *const ::std::os::raw::c_uchar, + pub b: *const ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_Fts5PhraseIter() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Fts5PhraseIter)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Fts5PhraseIter)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).a as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Fts5PhraseIter), + "::", + stringify!(a) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).b as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Fts5PhraseIter), + "::", + stringify!(b) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5ExtensionApi { + pub iVersion: ::std::os::raw::c_int, + pub xUserData: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> *mut ::std::os::raw::c_void, + >, + pub xColumnCount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, + >, + pub xRowCount: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pnRow: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xColumnTotalSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pnToken: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTokenize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pText: *const ::std::os::raw::c_char, + nText: ::std::os::raw::c_int, + pCtx: *mut ::std::os::raw::c_void, + xToken: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + arg6: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseCount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, + >, + pub xPhraseSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xInstCount: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pnInst: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xInst: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iIdx: ::std::os::raw::c_int, + piPhrase: *mut ::std::os::raw::c_int, + piCol: *mut ::std::os::raw::c_int, + piOff: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: + ::std::option::Option sqlite3_int64>, + pub xColumnText: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pz: *mut *const ::std::os::raw::c_char, + pn: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xColumnSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pnToken: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xQueryPhrase: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + pUserData: *mut ::std::os::raw::c_void, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const Fts5ExtensionApi, + arg2: *mut Fts5Context, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub xSetAuxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pAux: *mut ::std::os::raw::c_void, + xDelete: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub xGetAuxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + bClear: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xPhraseFirst: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + arg2: *mut Fts5PhraseIter, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseNext: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + arg2: *mut Fts5PhraseIter, + piCol: *mut ::std::os::raw::c_int, + piOff: *mut ::std::os::raw::c_int, + ), + >, + pub xPhraseFirstColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + arg2: *mut Fts5PhraseIter, + arg3: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseNextColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + arg2: *mut Fts5PhraseIter, + piCol: *mut ::std::os::raw::c_int, + ), + >, +} +#[test] +fn bindgen_test_layout_Fts5ExtensionApi() { + assert_eq!( + ::std::mem::size_of::(), + 160usize, + concat!("Size of: ", stringify!(Fts5ExtensionApi)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Fts5ExtensionApi)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUserData as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xUserData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnCount as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowCount as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xRowCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xColumnTotalSize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnTotalSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xTokenize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseCount as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseSize as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInstCount as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xInstCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInst as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xInst) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnText as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnText) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnSize as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xQueryPhrase as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xQueryPhrase) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetAuxdata as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xSetAuxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetAuxdata as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xGetAuxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseFirst as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseFirst) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseNext as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseNext) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPhraseFirstColumn as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseFirstColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPhraseNextColumn as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseNextColumn) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5Tokenizer { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct fts5_tokenizer { + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + azArg: *mut *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ppOut: *mut *mut Fts5Tokenizer, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option, + pub xTokenize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Tokenizer, + pCtx: *mut ::std::os::raw::c_void, + flags: ::std::os::raw::c_int, + pText: *const ::std::os::raw::c_char, + nText: ::std::os::raw::c_int, + xToken: ::std::option::Option< + unsafe extern "C" fn( + pCtx: *mut ::std::os::raw::c_void, + tflags: ::std::os::raw::c_int, + pToken: *const ::std::os::raw::c_char, + nToken: ::std::os::raw::c_int, + iStart: ::std::os::raw::c_int, + iEnd: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_fts5_tokenizer() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(fts5_tokenizer)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(fts5_tokenizer)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xTokenize) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct fts5_api { + pub iVersion: ::std::os::raw::c_int, + pub xCreateTokenizer: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + pContext: *mut ::std::os::raw::c_void, + pTokenizer: *mut fts5_tokenizer, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub xFindTokenizer: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + ppContext: *mut *mut ::std::os::raw::c_void, + pTokenizer: *mut fts5_tokenizer, + ) -> ::std::os::raw::c_int, + >, + pub xCreateFunction: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + pContext: *mut ::std::os::raw::c_void, + xFunction: fts5_extension_function, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_fts5_api() { + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(fts5_api)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(fts5_api)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreateTokenizer as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xCreateTokenizer) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindTokenizer as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xFindTokenizer) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreateFunction as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xCreateFunction) + ) + ); +} +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23-ext-embed.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23-ext-embed.rs new file mode 100644 index 000000000..603d84d38 --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23-ext-embed.rs @@ -0,0 +1,6855 @@ +/* automatically generated by rust-bindgen */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.6.23\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3006023; +pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = + b"2010-03-09 19:31:43 4ae453ea7be69018d8c16eb8dabe05617397dc4d\0"; +pub const SQLITE_OK: i32 = 0; +pub const SQLITE_ERROR: i32 = 1; +pub const SQLITE_INTERNAL: i32 = 2; +pub const SQLITE_PERM: i32 = 3; +pub const SQLITE_ABORT: i32 = 4; +pub const SQLITE_BUSY: i32 = 5; +pub const SQLITE_LOCKED: i32 = 6; +pub const SQLITE_NOMEM: i32 = 7; +pub const SQLITE_READONLY: i32 = 8; +pub const SQLITE_INTERRUPT: i32 = 9; +pub const SQLITE_IOERR: i32 = 10; +pub const SQLITE_CORRUPT: i32 = 11; +pub const SQLITE_NOTFOUND: i32 = 12; +pub const SQLITE_FULL: i32 = 13; +pub const SQLITE_CANTOPEN: i32 = 14; +pub const SQLITE_PROTOCOL: i32 = 15; +pub const SQLITE_EMPTY: i32 = 16; +pub const SQLITE_SCHEMA: i32 = 17; +pub const SQLITE_TOOBIG: i32 = 18; +pub const SQLITE_CONSTRAINT: i32 = 19; +pub const SQLITE_MISMATCH: i32 = 20; +pub const SQLITE_MISUSE: i32 = 21; +pub const SQLITE_NOLFS: i32 = 22; +pub const SQLITE_AUTH: i32 = 23; +pub const SQLITE_FORMAT: i32 = 24; +pub const SQLITE_RANGE: i32 = 25; +pub const SQLITE_NOTADB: i32 = 26; +pub const SQLITE_ROW: i32 = 100; +pub const SQLITE_DONE: i32 = 101; +pub const SQLITE_IOERR_READ: i32 = 266; +pub const SQLITE_IOERR_SHORT_READ: i32 = 522; +pub const SQLITE_IOERR_WRITE: i32 = 778; +pub const SQLITE_IOERR_FSYNC: i32 = 1034; +pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; +pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; +pub const SQLITE_IOERR_FSTAT: i32 = 1802; +pub const SQLITE_IOERR_UNLOCK: i32 = 2058; +pub const SQLITE_IOERR_RDLOCK: i32 = 2314; +pub const SQLITE_IOERR_DELETE: i32 = 2570; +pub const SQLITE_IOERR_BLOCKED: i32 = 2826; +pub const SQLITE_IOERR_NOMEM: i32 = 3082; +pub const SQLITE_IOERR_ACCESS: i32 = 3338; +pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; +pub const SQLITE_IOERR_LOCK: i32 = 3850; +pub const SQLITE_IOERR_CLOSE: i32 = 4106; +pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; +pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; +pub const SQLITE_OPEN_READONLY: i32 = 1; +pub const SQLITE_OPEN_READWRITE: i32 = 2; +pub const SQLITE_OPEN_CREATE: i32 = 4; +pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; +pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; +pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; +pub const SQLITE_OPEN_MAIN_DB: i32 = 256; +pub const SQLITE_OPEN_TEMP_DB: i32 = 512; +pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; +pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; +pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; +pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; +pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; +pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; +pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; +pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; +pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; +pub const SQLITE_IOCAP_ATOMIC: i32 = 1; +pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; +pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; +pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; +pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; +pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; +pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; +pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; +pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; +pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; +pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; +pub const SQLITE_LOCK_NONE: i32 = 0; +pub const SQLITE_LOCK_SHARED: i32 = 1; +pub const SQLITE_LOCK_RESERVED: i32 = 2; +pub const SQLITE_LOCK_PENDING: i32 = 3; +pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; +pub const SQLITE_SYNC_NORMAL: i32 = 2; +pub const SQLITE_SYNC_FULL: i32 = 3; +pub const SQLITE_SYNC_DATAONLY: i32 = 16; +pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; +pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_LAST_ERRNO: i32 = 4; +pub const SQLITE_ACCESS_EXISTS: i32 = 0; +pub const SQLITE_ACCESS_READWRITE: i32 = 1; +pub const SQLITE_ACCESS_READ: i32 = 2; +pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; +pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; +pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; +pub const SQLITE_CONFIG_MALLOC: i32 = 4; +pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; +pub const SQLITE_CONFIG_SCRATCH: i32 = 6; +pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; +pub const SQLITE_CONFIG_HEAP: i32 = 8; +pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; +pub const SQLITE_CONFIG_MUTEX: i32 = 10; +pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; +pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; +pub const SQLITE_CONFIG_PCACHE: i32 = 14; +pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; +pub const SQLITE_CONFIG_LOG: i32 = 16; +pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; +pub const SQLITE_DENY: i32 = 1; +pub const SQLITE_IGNORE: i32 = 2; +pub const SQLITE_CREATE_INDEX: i32 = 1; +pub const SQLITE_CREATE_TABLE: i32 = 2; +pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; +pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; +pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; +pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; +pub const SQLITE_CREATE_TRIGGER: i32 = 7; +pub const SQLITE_CREATE_VIEW: i32 = 8; +pub const SQLITE_DELETE: i32 = 9; +pub const SQLITE_DROP_INDEX: i32 = 10; +pub const SQLITE_DROP_TABLE: i32 = 11; +pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; +pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; +pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; +pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; +pub const SQLITE_DROP_TRIGGER: i32 = 16; +pub const SQLITE_DROP_VIEW: i32 = 17; +pub const SQLITE_INSERT: i32 = 18; +pub const SQLITE_PRAGMA: i32 = 19; +pub const SQLITE_READ: i32 = 20; +pub const SQLITE_SELECT: i32 = 21; +pub const SQLITE_TRANSACTION: i32 = 22; +pub const SQLITE_UPDATE: i32 = 23; +pub const SQLITE_ATTACH: i32 = 24; +pub const SQLITE_DETACH: i32 = 25; +pub const SQLITE_ALTER_TABLE: i32 = 26; +pub const SQLITE_REINDEX: i32 = 27; +pub const SQLITE_ANALYZE: i32 = 28; +pub const SQLITE_CREATE_VTABLE: i32 = 29; +pub const SQLITE_DROP_VTABLE: i32 = 30; +pub const SQLITE_FUNCTION: i32 = 31; +pub const SQLITE_SAVEPOINT: i32 = 32; +pub const SQLITE_COPY: i32 = 0; +pub const SQLITE_LIMIT_LENGTH: i32 = 0; +pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; +pub const SQLITE_LIMIT_COLUMN: i32 = 2; +pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; +pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; +pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; +pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; +pub const SQLITE_LIMIT_ATTACHED: i32 = 7; +pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; +pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; +pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; +pub const SQLITE_INTEGER: i32 = 1; +pub const SQLITE_FLOAT: i32 = 2; +pub const SQLITE_BLOB: i32 = 4; +pub const SQLITE_NULL: i32 = 5; +pub const SQLITE_TEXT: i32 = 3; +pub const SQLITE3_TEXT: i32 = 3; +pub const SQLITE_UTF8: i32 = 1; +pub const SQLITE_UTF16LE: i32 = 2; +pub const SQLITE_UTF16BE: i32 = 3; +pub const SQLITE_UTF16: i32 = 4; +pub const SQLITE_ANY: i32 = 5; +pub const SQLITE_UTF16_ALIGNED: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; +pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; +pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; +pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; +pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; +pub const SQLITE_MUTEX_FAST: i32 = 0; +pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; +pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; +pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; +pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; +pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; +pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; +pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; +pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; +pub const SQLITE_TESTCTRL_FIRST: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; +pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; +pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; +pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; +pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; +pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; +pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; +pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; +pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; +pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; +pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; +pub const SQLITE_TESTCTRL_LAST: i32 = 16; +pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; +pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; +pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; +pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; +pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; +pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; +pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; +pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; +pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; +pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; +pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; +pub const SQLITE_STMTSTATUS_SORT: i32 = 2; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; +extern "C" { + #[link_name = "\u{1}sqlite3_version"] + pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3 { + _unused: [u8; 0], +} +pub type sqlite_int64 = ::std::os::raw::c_longlong; +pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; +pub type sqlite3_int64 = sqlite_int64; +pub type sqlite3_uint64 = sqlite_uint64; +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_file { + pub pMethods: *const sqlite3_io_methods, +} +#[test] +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vfs { + pub iVersion: ::std::os::raw::c_int, + pub szOsFile: ::std::os::raw::c_int, + pub mxPathname: ::std::os::raw::c_int, + pub pNext: *mut sqlite3_vfs, + pub zName: *const ::std::os::raw::c_char, + pub pAppData: *mut ::std::os::raw::c_void, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_vfs() { + assert_eq!( + ::std::mem::size_of::(), + 136usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mem_methods { + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub pAppData: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_mem_methods() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_stmt { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Mem { + _unused: [u8; 0], +} +pub type sqlite3_value = Mem; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_context { + _unused: [u8; 0], +} +pub type sqlite3_destructor_type = + ::std::option::Option; +extern "C" { + #[link_name = "\u{1}sqlite3_temp_directory"] + pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 160usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info { + pub nConstraint: ::std::os::raw::c_int, + pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, + pub nOrderBy: ::std::os::raw::c_int, + pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, + pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, + pub idxNum: ::std::os::raw::c_int, + pub idxStr: *mut ::std::os::raw::c_char, + pub needToFreeIdxStr: ::std::os::raw::c_int, + pub orderByConsumed: ::std::os::raw::c_int, + pub estimatedCost: f64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint { + pub iColumn: ::std::os::raw::c_int, + pub op: ::std::os::raw::c_uchar, + pub usable: ::std::os::raw::c_uchar, + pub iTermOffset: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_orderby { + pub iColumn: ::std::os::raw::c_int, + pub desc: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint_usage { + pub argvIndex: ::std::os::raw::c_int, + pub omit: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); +} +#[test] +fn bindgen_test_layout_sqlite3_index_info() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_blob { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex_methods { + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_mutex_methods() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods { + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_backup { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_api_routines { + pub aggregate_context: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub aggregate_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, + >, + pub bind_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_double: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int, + >, + pub bind_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, + ) -> ::std::os::raw::c_int, + >, + pub bind_null: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub bind_parameter_index: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub bind_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub busy_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub busy_timeout: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub changes: + ::std::option::Option ::std::os::raw::c_int>, + pub close: + ::std::option::Option ::std::os::raw::c_int>, + pub collation_needed: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub collation_needed16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub column_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_bytes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_bytes16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub column_database_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_database_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_decltype: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_decltype16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_double: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, + >, + pub column_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_int64: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, + >, + pub column_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_origin_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_origin_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_table_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_table_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar, + >, + pub column_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_type: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value, + >, + pub commit_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub complete: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub complete16: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub create_collation: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_collation16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_function16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_module: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub data_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub db_handle: + ::std::option::Option *mut sqlite3>, + pub declare_vtab: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub enable_shared_cache: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub errmsg: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, + >, + pub errmsg16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, + >, + pub exec: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub expired: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub finalize: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub free: ::std::option::Option, + pub free_table: + ::std::option::Option, + pub get_autocommit: + ::std::option::Option ::std::os::raw::c_int>, + pub get_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub get_table: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub global_recover: ::std::option::Option ::std::os::raw::c_int>, + pub interruptx: ::std::option::Option, + pub last_insert_rowid: + ::std::option::Option sqlite_int64>, + pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, + pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, + pub malloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub mprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub open16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub prepare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub profile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub progress_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ), + >, + pub realloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub result_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_double: + ::std::option::Option, + pub result_error: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_error16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_int64: + ::std::option::Option, + pub result_null: ::std::option::Option, + pub result_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16be: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16le: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_value: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), + >, + pub rollback_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub set_authorizer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub set_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, + ), + >, + pub snprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub step: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub table_column_metadata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub thread_cleanup: ::std::option::Option, + pub total_changes: + ::std::option::Option ::std::os::raw::c_int>, + pub trace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub transfer_bindings: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int, + >, + pub update_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub user_data: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, + >, + pub value_blob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_bytes16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_double: ::std::option::Option f64>, + pub value_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_int64: + ::std::option::Option sqlite_int64>, + pub value_numeric_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_text: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, + >, + pub value_text16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16be: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16le: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub vmprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub overload_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub prepare_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub clear_bindings: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub create_module_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_close: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int, + >, + pub blob_read: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_write: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub create_collation_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub file_control: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub memory_highwater: + ::std::option::Option sqlite3_int64>, + pub memory_used: ::std::option::Option sqlite3_int64>, + pub mutex_alloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub mutex_enter: ::std::option::Option, + pub mutex_free: ::std::option::Option, + pub mutex_leave: ::std::option::Option, + pub mutex_try: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub open_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub release_memory: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub result_error_nomem: ::std::option::Option, + pub result_error_toobig: + ::std::option::Option, + pub sleep: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub soft_heap_limit: ::std::option::Option, + pub vfs_find: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, + >, + pub vfs_register: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub vfs_unregister: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, + >, + pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, + pub result_zeroblob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_error_code: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub test_control: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, + >, + pub randomness: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), + >, + pub context_db_handle: + ::std::option::Option *mut sqlite3>, + pub extended_result_codes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub limit: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub next_stmt: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, + >, + pub sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, + >, + pub status: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_api_routines() { + assert_eq!( + ::std::mem::size_of::(), + 1240usize, + concat!("Size of: ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_context as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_context) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_count as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_double as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_count as *const _ + as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_index as *const _ + as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_index) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_name as *const _ + as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text16 as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_handler as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_handler) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_timeout as *const _ as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_timeout) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed as *const _ as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_blob as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes as *const _ as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize + }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_count as *const _ as usize + }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name as *const _ + as usize + }, + 184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name16 as *const _ + as usize + }, + 192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype as *const _ as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize + }, + 208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_double as *const _ as usize + }, + 216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, + 224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_int64 as *const _ as usize + }, + 232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name as *const _ as usize + }, + 240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name16 as *const _ as usize + }, + 248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name as *const _ as usize + }, + 256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name16 as *const _ + as usize + }, + 264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name as *const _ as usize + }, + 272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name16 as *const _ + as usize + }, + 280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text as *const _ as usize + }, + 288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text16 as *const _ as usize + }, + 296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_type as *const _ as usize + }, + 304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_type) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_value as *const _ as usize + }, + 312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).commit_hook as *const _ as usize + }, + 320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(commit_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, + 328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, + 336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation as *const _ as usize + }, + 344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation16 as *const _ as usize + }, + 352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function as *const _ as usize + }, + 360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function16 as *const _ as usize + }, + 368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module as *const _ as usize + }, + 376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, + 384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(data_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, + 392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).declare_vtab as *const _ as usize + }, + 400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(declare_vtab) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).enable_shared_cache as *const _ + as usize + }, + 408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(enable_shared_cache) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, + 416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, + 424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, + 432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, + 440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(exec) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, + 448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(expired) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, + 456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(finalize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, + 464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, + 472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_autocommit as *const _ as usize + }, + 480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_autocommit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_auxdata as *const _ as usize + }, + 488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, + 496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).global_recover as *const _ as usize + }, + 504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(global_recover) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, + 512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(interruptx) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize + }, + 520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(last_insert_rowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, + 528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).libversion_number as *const _ as usize + }, + 536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion_number) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, + 544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, + 552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, + 560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, + 568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, + 576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, + 584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, + 592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(profile) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).progress_handler as *const _ as usize + }, + 600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(progress_handler) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, + 608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, + 616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob as *const _ as usize + }, + 624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_double as *const _ as usize + }, + 632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_double) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error as *const _ as usize + }, + 640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error16 as *const _ as usize + }, + 648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, + 656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_int64 as *const _ as usize + }, + 664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_null as *const _ as usize + }, + 672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text as *const _ as usize + }, + 680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16 as *const _ as usize + }, + 688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16be as *const _ as usize + }, + 696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16le as *const _ as usize + }, + 704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16le) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_value as *const _ as usize + }, + 712usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rollback_hook as *const _ as usize + }, + 720usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(rollback_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_authorizer as *const _ as usize + }, + 728usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_authorizer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_auxdata as *const _ as usize + }, + 736usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).snprintf as *const _ as usize }, + 744usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(snprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, + 752usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).table_column_metadata as *const _ + as usize + }, + 760usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(table_column_metadata) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize + }, + 768usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(thread_cleanup) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).total_changes as *const _ as usize + }, + 776usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(total_changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, + 784usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(trace) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize + }, + 792usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(transfer_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).update_hook as *const _ as usize + }, + 800usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(update_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, + 808usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(user_data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, + 816usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes as *const _ as usize + }, + 824usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize + }, + 832usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_double as *const _ as usize + }, + 840usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, + 848usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_int64 as *const _ as usize + }, + 856usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize + }, + 864usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_numeric_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, + 872usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16 as *const _ as usize + }, + 880usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16be as *const _ as usize + }, + 888usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16le as *const _ as usize + }, + 896usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16le) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, + 904usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, + 912usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vmprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).overload_function as *const _ as usize + }, + 920usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(overload_function) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, + 928usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize + }, + 936usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).clear_bindings as *const _ as usize + }, + 944usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(clear_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize + }, + 952usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize + }, + 960usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, + 968usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_bytes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, + 976usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_close) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, + 984usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, + 992usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_read) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, + 1000usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_write) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation_v2 as *const _ + as usize + }, + 1008usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).file_control as *const _ as usize + }, + 1016usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(file_control) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_highwater as *const _ as usize + }, + 1024usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_highwater) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_used as *const _ as usize + }, + 1032usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize + }, + 1040usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_alloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_enter as *const _ as usize + }, + 1048usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_enter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, + 1056usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_leave as *const _ as usize + }, + 1064usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_leave) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, + 1072usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_try) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, + 1080usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).release_memory as *const _ as usize + }, + 1088usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(release_memory) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize + }, + 1096usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_nomem) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_toobig as *const _ + as usize + }, + 1104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_toobig) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, + 1112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sleep) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize + }, + 1120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, + 1128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_find) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_register as *const _ as usize + }, + 1136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_register) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize + }, + 1144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_unregister) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize + }, + 1152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xthreadsafe) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize + }, + 1160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_code as *const _ as usize + }, + 1168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_code) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).test_control as *const _ as usize + }, + 1176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(test_control) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, + 1184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(randomness) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).context_db_handle as *const _ as usize + }, + 1192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(context_db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_result_codes as *const _ + as usize + }, + 1200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_result_codes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, + 1208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, + 1216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(next_stmt) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, + 1224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sql) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, + 1232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status) + ) + ); +} +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} + +// bindings were built with loadable_extension_embedded: +// define sqlite3_api as an extern since this code will be embedded +// within a loadable extension that defines and exports this itself +extern "C" { + #[no_mangle] + pub static mut sqlite3_api: *mut sqlite3_api_routines; +} + +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) + +pub unsafe fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_context.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_context", + " function" + )))(arg1, nBytes) +} + +pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_double", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_null", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_index.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_index", + " function" + )))(arg1, zName) +} + +pub unsafe fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_value", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_handler", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_timeout.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_timeout", + " function" + )))(arg1, ms) +} + +pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_blob", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype", + " function" + )))(arg1, i) +} + +pub unsafe fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_double", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int64", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_type", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_value", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).commit_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "commit_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete16", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_create_collation( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_collation16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_function( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_function16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function16", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_module( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).data_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "data_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).declare_vtab.expect(stringify!( + "sqlite3_api contains null pointer for ", + "declare_vtab", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).enable_shared_cache.expect(stringify!( + "sqlite3_api contains null pointer for ", + "enable_shared_cache", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errcode", + " function" + )))(db) +} + +pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_exec( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).exec.expect(stringify!( + "sqlite3_api contains null pointer for ", + "exec", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).expired.expect(stringify!( + "sqlite3_api contains null pointer for ", + "expired", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).finalize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "finalize", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free_table", + " function" + )))(result) +} + +pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_autocommit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_autocommit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_auxdata", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_get_table( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_table", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).global_recover.expect(stringify!( + "sqlite3_api contains null pointer for ", + "global_recover", + " function" + )))() +} + +pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).interruptx.expect(stringify!( + "sqlite3_api contains null pointer for ", + "interruptx", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).last_insert_rowid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "last_insert_rowid", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion", + " function" + )))() +} + +pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion_number.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion_number", + " function" + )))() +} + +pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mprintf( + arg1: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mprintf", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_open( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_open16( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_prepare( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_profile( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).profile.expect(stringify!( + "sqlite3_api contains null pointer for ", + "profile", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).progress_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "progress_handler", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_double", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_null", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16be", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16le", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_value", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).rollback_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "rollback_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_authorizer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_authorizer", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_auxdata", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_snprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).snprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "snprintf", + " function" + )))(arg1, arg2, arg3, vararg1) +} + +pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "step", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_table_column_metadata( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).table_column_metadata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "table_column_metadata", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) +} + +pub unsafe fn sqlite3_thread_cleanup() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).thread_cleanup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "thread_cleanup", + " function" + )))() +} + +pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).total_changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "total_changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).trace.expect(stringify!( + "sqlite3_api contains null pointer for ", + "trace", + " function" + )))(arg1, xTrace, arg2) +} + +pub unsafe fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).transfer_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "transfer_bindings", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).update_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "update_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).user_data.expect(stringify!( + "sqlite3_api contains null pointer for ", + "user_data", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_blob", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_double", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_numeric_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_numeric_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16be", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16le", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vmprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vmprintf", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).overload_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "overload_function", + " function" + )))(arg1, zFuncName, nArg) +} + +pub unsafe fn sqlite3_prepare_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).clear_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "clear_bindings", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_module_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module_v2", + " function" + )))(arg1, arg2, arg3, arg4, xDestroy) +} + +pub unsafe fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_open( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_open", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) +} + +pub unsafe fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_read.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_read", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_write.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_write", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_file_control( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).file_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "file_control", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_highwater.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_highwater", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_used", + " function" + )))() +} + +pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_alloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_alloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_enter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_enter", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_leave.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_leave", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_try.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_try", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_open_v2( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open_v2", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_nomem.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_nomem", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_toobig.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_toobig", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sleep.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sleep", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_find.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_find", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_register.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_register", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_unregister.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_unregister", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xthreadsafe.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xthreadsafe", + " function" + )))() +} + +pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_code.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_code", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_test_control( + arg1: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).test_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "test_control", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).randomness.expect(stringify!( + "sqlite3_api contains null pointer for ", + "randomness", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).context_db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "context_db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_result_codes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_result_codes", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_limit( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "limit", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).next_stmt.expect(stringify!( + "sqlite3_api contains null pointer for ", + "next_stmt", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_status( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub const SQLITE_DETERMINISTIC: i32 = 2048; diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23-ext.rs new file mode 100644 index 000000000..d38ed33e6 --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23-ext.rs @@ -0,0 +1,6853 @@ +/* automatically generated by rust-bindgen */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.6.23\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3006023; +pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = + b"2010-03-09 19:31:43 4ae453ea7be69018d8c16eb8dabe05617397dc4d\0"; +pub const SQLITE_OK: i32 = 0; +pub const SQLITE_ERROR: i32 = 1; +pub const SQLITE_INTERNAL: i32 = 2; +pub const SQLITE_PERM: i32 = 3; +pub const SQLITE_ABORT: i32 = 4; +pub const SQLITE_BUSY: i32 = 5; +pub const SQLITE_LOCKED: i32 = 6; +pub const SQLITE_NOMEM: i32 = 7; +pub const SQLITE_READONLY: i32 = 8; +pub const SQLITE_INTERRUPT: i32 = 9; +pub const SQLITE_IOERR: i32 = 10; +pub const SQLITE_CORRUPT: i32 = 11; +pub const SQLITE_NOTFOUND: i32 = 12; +pub const SQLITE_FULL: i32 = 13; +pub const SQLITE_CANTOPEN: i32 = 14; +pub const SQLITE_PROTOCOL: i32 = 15; +pub const SQLITE_EMPTY: i32 = 16; +pub const SQLITE_SCHEMA: i32 = 17; +pub const SQLITE_TOOBIG: i32 = 18; +pub const SQLITE_CONSTRAINT: i32 = 19; +pub const SQLITE_MISMATCH: i32 = 20; +pub const SQLITE_MISUSE: i32 = 21; +pub const SQLITE_NOLFS: i32 = 22; +pub const SQLITE_AUTH: i32 = 23; +pub const SQLITE_FORMAT: i32 = 24; +pub const SQLITE_RANGE: i32 = 25; +pub const SQLITE_NOTADB: i32 = 26; +pub const SQLITE_ROW: i32 = 100; +pub const SQLITE_DONE: i32 = 101; +pub const SQLITE_IOERR_READ: i32 = 266; +pub const SQLITE_IOERR_SHORT_READ: i32 = 522; +pub const SQLITE_IOERR_WRITE: i32 = 778; +pub const SQLITE_IOERR_FSYNC: i32 = 1034; +pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; +pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; +pub const SQLITE_IOERR_FSTAT: i32 = 1802; +pub const SQLITE_IOERR_UNLOCK: i32 = 2058; +pub const SQLITE_IOERR_RDLOCK: i32 = 2314; +pub const SQLITE_IOERR_DELETE: i32 = 2570; +pub const SQLITE_IOERR_BLOCKED: i32 = 2826; +pub const SQLITE_IOERR_NOMEM: i32 = 3082; +pub const SQLITE_IOERR_ACCESS: i32 = 3338; +pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; +pub const SQLITE_IOERR_LOCK: i32 = 3850; +pub const SQLITE_IOERR_CLOSE: i32 = 4106; +pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; +pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; +pub const SQLITE_OPEN_READONLY: i32 = 1; +pub const SQLITE_OPEN_READWRITE: i32 = 2; +pub const SQLITE_OPEN_CREATE: i32 = 4; +pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; +pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; +pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; +pub const SQLITE_OPEN_MAIN_DB: i32 = 256; +pub const SQLITE_OPEN_TEMP_DB: i32 = 512; +pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; +pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; +pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; +pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; +pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; +pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; +pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; +pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; +pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; +pub const SQLITE_IOCAP_ATOMIC: i32 = 1; +pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; +pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; +pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; +pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; +pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; +pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; +pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; +pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; +pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; +pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; +pub const SQLITE_LOCK_NONE: i32 = 0; +pub const SQLITE_LOCK_SHARED: i32 = 1; +pub const SQLITE_LOCK_RESERVED: i32 = 2; +pub const SQLITE_LOCK_PENDING: i32 = 3; +pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; +pub const SQLITE_SYNC_NORMAL: i32 = 2; +pub const SQLITE_SYNC_FULL: i32 = 3; +pub const SQLITE_SYNC_DATAONLY: i32 = 16; +pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; +pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_LAST_ERRNO: i32 = 4; +pub const SQLITE_ACCESS_EXISTS: i32 = 0; +pub const SQLITE_ACCESS_READWRITE: i32 = 1; +pub const SQLITE_ACCESS_READ: i32 = 2; +pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; +pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; +pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; +pub const SQLITE_CONFIG_MALLOC: i32 = 4; +pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; +pub const SQLITE_CONFIG_SCRATCH: i32 = 6; +pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; +pub const SQLITE_CONFIG_HEAP: i32 = 8; +pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; +pub const SQLITE_CONFIG_MUTEX: i32 = 10; +pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; +pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; +pub const SQLITE_CONFIG_PCACHE: i32 = 14; +pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; +pub const SQLITE_CONFIG_LOG: i32 = 16; +pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; +pub const SQLITE_DENY: i32 = 1; +pub const SQLITE_IGNORE: i32 = 2; +pub const SQLITE_CREATE_INDEX: i32 = 1; +pub const SQLITE_CREATE_TABLE: i32 = 2; +pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; +pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; +pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; +pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; +pub const SQLITE_CREATE_TRIGGER: i32 = 7; +pub const SQLITE_CREATE_VIEW: i32 = 8; +pub const SQLITE_DELETE: i32 = 9; +pub const SQLITE_DROP_INDEX: i32 = 10; +pub const SQLITE_DROP_TABLE: i32 = 11; +pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; +pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; +pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; +pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; +pub const SQLITE_DROP_TRIGGER: i32 = 16; +pub const SQLITE_DROP_VIEW: i32 = 17; +pub const SQLITE_INSERT: i32 = 18; +pub const SQLITE_PRAGMA: i32 = 19; +pub const SQLITE_READ: i32 = 20; +pub const SQLITE_SELECT: i32 = 21; +pub const SQLITE_TRANSACTION: i32 = 22; +pub const SQLITE_UPDATE: i32 = 23; +pub const SQLITE_ATTACH: i32 = 24; +pub const SQLITE_DETACH: i32 = 25; +pub const SQLITE_ALTER_TABLE: i32 = 26; +pub const SQLITE_REINDEX: i32 = 27; +pub const SQLITE_ANALYZE: i32 = 28; +pub const SQLITE_CREATE_VTABLE: i32 = 29; +pub const SQLITE_DROP_VTABLE: i32 = 30; +pub const SQLITE_FUNCTION: i32 = 31; +pub const SQLITE_SAVEPOINT: i32 = 32; +pub const SQLITE_COPY: i32 = 0; +pub const SQLITE_LIMIT_LENGTH: i32 = 0; +pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; +pub const SQLITE_LIMIT_COLUMN: i32 = 2; +pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; +pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; +pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; +pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; +pub const SQLITE_LIMIT_ATTACHED: i32 = 7; +pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; +pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; +pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; +pub const SQLITE_INTEGER: i32 = 1; +pub const SQLITE_FLOAT: i32 = 2; +pub const SQLITE_BLOB: i32 = 4; +pub const SQLITE_NULL: i32 = 5; +pub const SQLITE_TEXT: i32 = 3; +pub const SQLITE3_TEXT: i32 = 3; +pub const SQLITE_UTF8: i32 = 1; +pub const SQLITE_UTF16LE: i32 = 2; +pub const SQLITE_UTF16BE: i32 = 3; +pub const SQLITE_UTF16: i32 = 4; +pub const SQLITE_ANY: i32 = 5; +pub const SQLITE_UTF16_ALIGNED: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; +pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; +pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; +pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; +pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; +pub const SQLITE_MUTEX_FAST: i32 = 0; +pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; +pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; +pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; +pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; +pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; +pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; +pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; +pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; +pub const SQLITE_TESTCTRL_FIRST: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; +pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; +pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; +pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; +pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; +pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; +pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; +pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; +pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; +pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; +pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; +pub const SQLITE_TESTCTRL_LAST: i32 = 16; +pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; +pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; +pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; +pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; +pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; +pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; +pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; +pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; +pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; +pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; +pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; +pub const SQLITE_STMTSTATUS_SORT: i32 = 2; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; +extern "C" { + #[link_name = "\u{1}sqlite3_version"] + pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3 { + _unused: [u8; 0], +} +pub type sqlite_int64 = ::std::os::raw::c_longlong; +pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; +pub type sqlite3_int64 = sqlite_int64; +pub type sqlite3_uint64 = sqlite_uint64; +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_file { + pub pMethods: *const sqlite3_io_methods, +} +#[test] +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vfs { + pub iVersion: ::std::os::raw::c_int, + pub szOsFile: ::std::os::raw::c_int, + pub mxPathname: ::std::os::raw::c_int, + pub pNext: *mut sqlite3_vfs, + pub zName: *const ::std::os::raw::c_char, + pub pAppData: *mut ::std::os::raw::c_void, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_vfs() { + assert_eq!( + ::std::mem::size_of::(), + 136usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mem_methods { + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub pAppData: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_mem_methods() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_stmt { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Mem { + _unused: [u8; 0], +} +pub type sqlite3_value = Mem; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_context { + _unused: [u8; 0], +} +pub type sqlite3_destructor_type = + ::std::option::Option; +extern "C" { + #[link_name = "\u{1}sqlite3_temp_directory"] + pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 160usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info { + pub nConstraint: ::std::os::raw::c_int, + pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, + pub nOrderBy: ::std::os::raw::c_int, + pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, + pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, + pub idxNum: ::std::os::raw::c_int, + pub idxStr: *mut ::std::os::raw::c_char, + pub needToFreeIdxStr: ::std::os::raw::c_int, + pub orderByConsumed: ::std::os::raw::c_int, + pub estimatedCost: f64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint { + pub iColumn: ::std::os::raw::c_int, + pub op: ::std::os::raw::c_uchar, + pub usable: ::std::os::raw::c_uchar, + pub iTermOffset: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_orderby { + pub iColumn: ::std::os::raw::c_int, + pub desc: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint_usage { + pub argvIndex: ::std::os::raw::c_int, + pub omit: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); +} +#[test] +fn bindgen_test_layout_sqlite3_index_info() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_blob { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex_methods { + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_mutex_methods() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods { + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_backup { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_api_routines { + pub aggregate_context: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub aggregate_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, + >, + pub bind_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_double: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int, + >, + pub bind_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, + ) -> ::std::os::raw::c_int, + >, + pub bind_null: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub bind_parameter_index: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub bind_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub busy_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub busy_timeout: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub changes: + ::std::option::Option ::std::os::raw::c_int>, + pub close: + ::std::option::Option ::std::os::raw::c_int>, + pub collation_needed: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub collation_needed16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub column_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_bytes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_bytes16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub column_database_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_database_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_decltype: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_decltype16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_double: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, + >, + pub column_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_int64: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, + >, + pub column_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_origin_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_origin_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_table_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_table_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar, + >, + pub column_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_type: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value, + >, + pub commit_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub complete: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub complete16: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub create_collation: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_collation16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_function16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_module: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub data_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub db_handle: + ::std::option::Option *mut sqlite3>, + pub declare_vtab: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub enable_shared_cache: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub errmsg: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, + >, + pub errmsg16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, + >, + pub exec: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub expired: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub finalize: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub free: ::std::option::Option, + pub free_table: + ::std::option::Option, + pub get_autocommit: + ::std::option::Option ::std::os::raw::c_int>, + pub get_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub get_table: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub global_recover: ::std::option::Option ::std::os::raw::c_int>, + pub interruptx: ::std::option::Option, + pub last_insert_rowid: + ::std::option::Option sqlite_int64>, + pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, + pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, + pub malloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub mprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub open16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub prepare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub profile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub progress_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ), + >, + pub realloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub result_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_double: + ::std::option::Option, + pub result_error: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_error16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_int64: + ::std::option::Option, + pub result_null: ::std::option::Option, + pub result_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16be: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16le: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_value: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), + >, + pub rollback_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub set_authorizer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub set_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, + ), + >, + pub snprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub step: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub table_column_metadata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub thread_cleanup: ::std::option::Option, + pub total_changes: + ::std::option::Option ::std::os::raw::c_int>, + pub trace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub transfer_bindings: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int, + >, + pub update_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub user_data: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, + >, + pub value_blob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_bytes16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_double: ::std::option::Option f64>, + pub value_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_int64: + ::std::option::Option sqlite_int64>, + pub value_numeric_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_text: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, + >, + pub value_text16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16be: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16le: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub vmprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub overload_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub prepare_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub clear_bindings: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub create_module_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_close: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int, + >, + pub blob_read: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_write: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub create_collation_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub file_control: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub memory_highwater: + ::std::option::Option sqlite3_int64>, + pub memory_used: ::std::option::Option sqlite3_int64>, + pub mutex_alloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub mutex_enter: ::std::option::Option, + pub mutex_free: ::std::option::Option, + pub mutex_leave: ::std::option::Option, + pub mutex_try: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub open_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub release_memory: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub result_error_nomem: ::std::option::Option, + pub result_error_toobig: + ::std::option::Option, + pub sleep: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub soft_heap_limit: ::std::option::Option, + pub vfs_find: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, + >, + pub vfs_register: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub vfs_unregister: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, + >, + pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, + pub result_zeroblob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_error_code: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub test_control: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, + >, + pub randomness: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), + >, + pub context_db_handle: + ::std::option::Option *mut sqlite3>, + pub extended_result_codes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub limit: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub next_stmt: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, + >, + pub sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, + >, + pub status: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_api_routines() { + assert_eq!( + ::std::mem::size_of::(), + 1240usize, + concat!("Size of: ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_context as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_context) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_count as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_double as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_count as *const _ + as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_index as *const _ + as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_index) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_name as *const _ + as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text16 as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_handler as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_handler) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_timeout as *const _ as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_timeout) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed as *const _ as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_blob as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes as *const _ as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize + }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_count as *const _ as usize + }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name as *const _ + as usize + }, + 184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name16 as *const _ + as usize + }, + 192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype as *const _ as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize + }, + 208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_double as *const _ as usize + }, + 216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, + 224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_int64 as *const _ as usize + }, + 232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name as *const _ as usize + }, + 240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name16 as *const _ as usize + }, + 248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name as *const _ as usize + }, + 256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name16 as *const _ + as usize + }, + 264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name as *const _ as usize + }, + 272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name16 as *const _ + as usize + }, + 280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text as *const _ as usize + }, + 288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text16 as *const _ as usize + }, + 296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_type as *const _ as usize + }, + 304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_type) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_value as *const _ as usize + }, + 312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).commit_hook as *const _ as usize + }, + 320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(commit_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, + 328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, + 336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation as *const _ as usize + }, + 344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation16 as *const _ as usize + }, + 352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function as *const _ as usize + }, + 360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function16 as *const _ as usize + }, + 368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module as *const _ as usize + }, + 376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, + 384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(data_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, + 392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).declare_vtab as *const _ as usize + }, + 400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(declare_vtab) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).enable_shared_cache as *const _ + as usize + }, + 408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(enable_shared_cache) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, + 416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, + 424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, + 432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, + 440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(exec) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, + 448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(expired) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, + 456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(finalize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, + 464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, + 472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_autocommit as *const _ as usize + }, + 480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_autocommit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_auxdata as *const _ as usize + }, + 488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, + 496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).global_recover as *const _ as usize + }, + 504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(global_recover) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, + 512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(interruptx) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize + }, + 520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(last_insert_rowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, + 528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).libversion_number as *const _ as usize + }, + 536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion_number) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, + 544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, + 552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, + 560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, + 568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, + 576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, + 584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, + 592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(profile) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).progress_handler as *const _ as usize + }, + 600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(progress_handler) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, + 608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, + 616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob as *const _ as usize + }, + 624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_double as *const _ as usize + }, + 632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_double) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error as *const _ as usize + }, + 640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error16 as *const _ as usize + }, + 648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, + 656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_int64 as *const _ as usize + }, + 664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_null as *const _ as usize + }, + 672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text as *const _ as usize + }, + 680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16 as *const _ as usize + }, + 688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16be as *const _ as usize + }, + 696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16le as *const _ as usize + }, + 704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16le) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_value as *const _ as usize + }, + 712usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rollback_hook as *const _ as usize + }, + 720usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(rollback_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_authorizer as *const _ as usize + }, + 728usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_authorizer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_auxdata as *const _ as usize + }, + 736usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).snprintf as *const _ as usize }, + 744usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(snprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, + 752usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).table_column_metadata as *const _ + as usize + }, + 760usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(table_column_metadata) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize + }, + 768usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(thread_cleanup) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).total_changes as *const _ as usize + }, + 776usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(total_changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, + 784usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(trace) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize + }, + 792usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(transfer_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).update_hook as *const _ as usize + }, + 800usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(update_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, + 808usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(user_data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, + 816usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes as *const _ as usize + }, + 824usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize + }, + 832usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_double as *const _ as usize + }, + 840usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, + 848usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_int64 as *const _ as usize + }, + 856usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize + }, + 864usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_numeric_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, + 872usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16 as *const _ as usize + }, + 880usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16be as *const _ as usize + }, + 888usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16le as *const _ as usize + }, + 896usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16le) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, + 904usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, + 912usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vmprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).overload_function as *const _ as usize + }, + 920usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(overload_function) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, + 928usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize + }, + 936usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).clear_bindings as *const _ as usize + }, + 944usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(clear_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize + }, + 952usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize + }, + 960usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, + 968usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_bytes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, + 976usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_close) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, + 984usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, + 992usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_read) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, + 1000usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_write) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation_v2 as *const _ + as usize + }, + 1008usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).file_control as *const _ as usize + }, + 1016usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(file_control) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_highwater as *const _ as usize + }, + 1024usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_highwater) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_used as *const _ as usize + }, + 1032usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize + }, + 1040usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_alloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_enter as *const _ as usize + }, + 1048usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_enter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, + 1056usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_leave as *const _ as usize + }, + 1064usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_leave) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, + 1072usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_try) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, + 1080usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).release_memory as *const _ as usize + }, + 1088usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(release_memory) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize + }, + 1096usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_nomem) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_toobig as *const _ + as usize + }, + 1104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_toobig) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, + 1112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sleep) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize + }, + 1120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, + 1128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_find) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_register as *const _ as usize + }, + 1136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_register) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize + }, + 1144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_unregister) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize + }, + 1152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xthreadsafe) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize + }, + 1160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_code as *const _ as usize + }, + 1168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_code) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).test_control as *const _ as usize + }, + 1176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(test_control) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, + 1184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(randomness) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).context_db_handle as *const _ as usize + }, + 1192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(context_db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_result_codes as *const _ + as usize + }, + 1200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_result_codes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, + 1208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, + 1216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(next_stmt) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, + 1224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sql) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, + 1232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status) + ) + ); +} +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} + +// bindings were built with (non-embedded) loadable_extension: +// we define our own sqlite_api static variable and export it +// to C +#[no_mangle] +pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_routines; + +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) + +pub unsafe fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_context.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_context", + " function" + )))(arg1, nBytes) +} + +pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_double", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_null", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_index.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_index", + " function" + )))(arg1, zName) +} + +pub unsafe fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_value", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_handler", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_timeout.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_timeout", + " function" + )))(arg1, ms) +} + +pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_blob", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype", + " function" + )))(arg1, i) +} + +pub unsafe fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_double", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int64", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_type", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_value", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).commit_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "commit_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete16", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_create_collation( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_collation16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_function( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_function16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function16", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_module( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).data_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "data_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).declare_vtab.expect(stringify!( + "sqlite3_api contains null pointer for ", + "declare_vtab", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).enable_shared_cache.expect(stringify!( + "sqlite3_api contains null pointer for ", + "enable_shared_cache", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errcode", + " function" + )))(db) +} + +pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_exec( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).exec.expect(stringify!( + "sqlite3_api contains null pointer for ", + "exec", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).expired.expect(stringify!( + "sqlite3_api contains null pointer for ", + "expired", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).finalize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "finalize", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free_table", + " function" + )))(result) +} + +pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_autocommit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_autocommit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_auxdata", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_get_table( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_table", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).global_recover.expect(stringify!( + "sqlite3_api contains null pointer for ", + "global_recover", + " function" + )))() +} + +pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).interruptx.expect(stringify!( + "sqlite3_api contains null pointer for ", + "interruptx", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).last_insert_rowid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "last_insert_rowid", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion", + " function" + )))() +} + +pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion_number.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion_number", + " function" + )))() +} + +pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mprintf( + arg1: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mprintf", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_open( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_open16( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_prepare( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_profile( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).profile.expect(stringify!( + "sqlite3_api contains null pointer for ", + "profile", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).progress_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "progress_handler", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_double", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_null", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16be", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16le", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_value", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).rollback_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "rollback_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_authorizer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_authorizer", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_auxdata", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_snprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).snprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "snprintf", + " function" + )))(arg1, arg2, arg3, vararg1) +} + +pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "step", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_table_column_metadata( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).table_column_metadata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "table_column_metadata", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) +} + +pub unsafe fn sqlite3_thread_cleanup() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).thread_cleanup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "thread_cleanup", + " function" + )))() +} + +pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).total_changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "total_changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).trace.expect(stringify!( + "sqlite3_api contains null pointer for ", + "trace", + " function" + )))(arg1, xTrace, arg2) +} + +pub unsafe fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).transfer_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "transfer_bindings", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).update_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "update_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).user_data.expect(stringify!( + "sqlite3_api contains null pointer for ", + "user_data", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_blob", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_double", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_numeric_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_numeric_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16be", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16le", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vmprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vmprintf", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).overload_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "overload_function", + " function" + )))(arg1, zFuncName, nArg) +} + +pub unsafe fn sqlite3_prepare_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).clear_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "clear_bindings", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_module_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module_v2", + " function" + )))(arg1, arg2, arg3, arg4, xDestroy) +} + +pub unsafe fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_open( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_open", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) +} + +pub unsafe fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_read.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_read", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_write.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_write", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_file_control( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).file_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "file_control", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_highwater.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_highwater", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_used", + " function" + )))() +} + +pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_alloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_alloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_enter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_enter", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_leave.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_leave", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_try.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_try", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_open_v2( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open_v2", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_nomem.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_nomem", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_toobig.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_toobig", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sleep.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sleep", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_find.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_find", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_register.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_register", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_unregister.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_unregister", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xthreadsafe.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xthreadsafe", + " function" + )))() +} + +pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_code.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_code", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_test_control( + arg1: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).test_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "test_control", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).randomness.expect(stringify!( + "sqlite3_api contains null pointer for ", + "randomness", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).context_db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "context_db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_result_codes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_result_codes", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_limit( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "limit", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).next_stmt.expect(stringify!( + "sqlite3_api contains null pointer for ", + "next_stmt", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_status( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub const SQLITE_DETERMINISTIC: i32 = 2048; diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23.rs index 673b11ddb..5fd7f84c5 100644 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23.rs +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23.rs @@ -1,10 +1,10 @@ /* automatically generated by rust-bindgen */ pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.6.23\x00"; +pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.6.23\0"; pub const SQLITE_VERSION_NUMBER: i32 = 3006023; pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = - b"2010-03-09 19:31:43 4ae453ea7be69018d8c16eb8dabe05617397dc4d\x00"; + b"2010-03-09 19:31:43 4ae453ea7be69018d8c16eb8dabe05617397dc4d\0"; pub const SQLITE_OK: i32 = 0; pub const SQLITE_ERROR: i32 = 1; pub const SQLITE_INTERNAL: i32 = 2; @@ -213,7 +213,7 @@ pub const SQLITE_STMTSTATUS_SORT: i32 = 2; pub type va_list = __builtin_va_list; pub type __gnuc_va_list = __builtin_va_list; extern "C" { - #[link_name = "sqlite3_version"] + #[link_name = "\u{1}sqlite3_version"] pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; } extern "C" { @@ -226,19 +226,21 @@ extern "C" { pub fn sqlite3_libversion_number() -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_compileoption_used(zOptName: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_compileoption_used( + zOptName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_compileoption_get(N: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_compileoption_get(N: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; } extern "C" { pub fn sqlite3_threadsafe() -> ::std::os::raw::c_int; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3([u8; 0]); +pub struct sqlite3 { + _unused: [u8; 0], +} pub type sqlite_int64 = ::std::os::raw::c_longlong; pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; pub type sqlite3_int64 = sqlite_int64; @@ -246,133 +248,283 @@ pub type sqlite3_uint64 = sqlite_uint64; extern "C" { pub fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int; } -pub type sqlite3_callback = - ::std::option::Option ::std::os::raw::c_int>; -extern "C" { - pub fn sqlite3_exec(arg1: *mut sqlite3, - sql: *const ::std::os::raw::c_char, - callback: - ::std::option::Option - ::std::os::raw::c_int>, - arg2: *mut ::std::os::raw::c_void, - errmsg: *mut *mut ::std::os::raw::c_char) - -> ::std::os::raw::c_int; +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +extern "C" { + pub fn sqlite3_exec( + arg1: *mut sqlite3, + sql: *const ::std::os::raw::c_char, + callback: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg2: *mut ::std::os::raw::c_void, + errmsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_file { - pub pMethods: *const sqlite3_file_sqlite3_io_methods, -} -#[repr(C)] -#[derive(Debug, Copy)] -pub struct sqlite3_file_sqlite3_io_methods { - pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option ::std::os::raw::c_int>, - pub xRead: ::std::option::Option ::std::os::raw::c_int>, - pub xWrite: ::std::option::Option ::std::os::raw::c_int>, - pub xTruncate: ::std::option::Option ::std::os::raw::c_int>, - pub xSync: ::std::option::Option ::std::os::raw::c_int>, - pub xFileSize: ::std::option::Option ::std::os::raw::c_int>, - pub xLock: ::std::option::Option ::std::os::raw::c_int>, - pub xUnlock: ::std::option::Option ::std::os::raw::c_int>, - pub xCheckReservedLock: ::std::option::Option - ::std::os::raw::c_int>, - pub xFileControl: ::std::option::Option ::std::os::raw::c_int>, - pub xSectorSize: ::std::option::Option ::std::os::raw::c_int>, - pub xDeviceCharacteristics: ::std::option::Option - ::std::os::raw::c_int>, + pub pMethods: *const sqlite3_io_methods, } #[test] -fn bindgen_test_layout_sqlite3_file_sqlite3_io_methods() { - assert_eq!(::std::mem::size_of::() , - 104usize); - assert_eq!(::std::mem::align_of::() , - 8usize); +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); } -impl Clone for sqlite3_file_sqlite3_io_methods { - fn clone(&self) -> Self { *self } +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, } #[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!(::std::mem::size_of::() , 8usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_file { - fn clone(&self) -> Self { *self } +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); } -pub type sqlite3_io_methods = sqlite3_file_sqlite3_io_methods; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex([u8; 0]); +pub struct sqlite3_mutex { + _unused: [u8; 0], +} #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_vfs { pub iVersion: ::std::os::raw::c_int, pub szOsFile: ::std::os::raw::c_int, @@ -380,97 +532,283 @@ pub struct sqlite3_vfs { pub pNext: *mut sqlite3_vfs, pub zName: *const ::std::os::raw::c_char, pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option ::std::os::raw::c_int>, - pub xDelete: ::std::option::Option ::std::os::raw::c_int>, - pub xAccess: ::std::option::Option ::std::os::raw::c_int>, - pub xFullPathname: ::std::option::Option ::std::os::raw::c_int>, - pub xDlOpen: ::std::option::Option *mut ::std::os::raw::c_void>, - pub xDlError: ::std::option::Option, - pub xDlSym: ::std::option::Option - ::std::option::Option>, - pub xDlClose: ::std::option::Option, - pub xRandomness: ::std::option::Option ::std::os::raw::c_int>, - pub xSleep: ::std::option::Option ::std::os::raw::c_int>, - pub xCurrentTime: ::std::option::Option ::std::os::raw::c_int>, - pub xGetLastError: ::std::option::Option ::std::os::raw::c_int>, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, } #[test] fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!(::std::mem::size_of::() , 136usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_vfs { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 136usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); } extern "C" { pub fn sqlite3_initialize() -> ::std::os::raw::c_int; @@ -485,52 +823,138 @@ extern "C" { pub fn sqlite3_os_end() -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) - -> ::std::os::raw::c_int; + pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_db_config(arg1: *mut sqlite3, - op: ::std::os::raw::c_int, ...) - -> ::std::os::raw::c_int; + pub fn sqlite3_db_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option *mut ::std::os::raw::c_void>, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option *mut ::std::os::raw::c_void>, - pub xSize: ::std::option::Option ::std::os::raw::c_int>, - pub xRoundup: ::std::option::Option ::std::os::raw::c_int>, - pub xInit: ::std::option::Option ::std::os::raw::c_int>, - pub xShutdown: ::std::option::Option, + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, pub pAppData: *mut ::std::os::raw::c_void, } #[test] fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!(::std::mem::size_of::() , 64usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_mem_methods { - fn clone(&self) -> Self { *self } -} -extern "C" { - pub fn sqlite3_extended_result_codes(arg1: *mut sqlite3, - onoff: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +extern "C" { + pub fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + onoff: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite3_int64; @@ -545,64 +969,68 @@ extern "C" { pub fn sqlite3_interrupt(arg1: *mut sqlite3); } extern "C" { - pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_busy_handler(arg1: *mut sqlite3, - arg2: - ::std::option::Option - ::std::os::raw::c_int>, - arg3: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_busy_timeout(arg1: *mut sqlite3, ms: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_get_table(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - pazResult: *mut *mut *mut ::std::os::raw::c_char, - pnRow: *mut ::std::os::raw::c_int, - pnColumn: *mut ::std::os::raw::c_int, - pzErrmsg: *mut *mut ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_get_table( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + pazResult: *mut *mut *mut ::std::os::raw::c_char, + pnRow: *mut ::std::os::raw::c_int, + pnColumn: *mut ::std::os::raw::c_int, + pzErrmsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char); } extern "C" { pub fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char, ...) - -> *mut ::std::os::raw::c_char; + -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_vmprintf(arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag) - -> *mut ::std::os::raw::c_char; + pub fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_snprintf(arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, ...) - -> *mut ::std::os::raw::c_char; + pub fn sqlite3_snprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_realloc(arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; } extern "C" { pub fn sqlite3_free(arg1: *mut ::std::os::raw::c_void); @@ -611,406 +1039,433 @@ extern "C" { pub fn sqlite3_memory_used() -> sqlite3_int64; } extern "C" { - pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) - -> sqlite3_int64; + pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) -> sqlite3_int64; } extern "C" { - pub fn sqlite3_randomness(N: ::std::os::raw::c_int, - P: *mut ::std::os::raw::c_void); + pub fn sqlite3_randomness(N: ::std::os::raw::c_int, P: *mut ::std::os::raw::c_void); } extern "C" { - pub fn sqlite3_set_authorizer(arg1: *mut sqlite3, - xAuth: - ::std::option::Option - ::std::os::raw::c_int>, - pUserData: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + xAuth: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pUserData: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_trace(arg1: *mut sqlite3, - xTrace: - ::std::option::Option, - arg2: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_profile(arg1: *mut sqlite3, - xProfile: - ::std::option::Option, - arg2: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_profile( + arg1: *mut sqlite3, + xProfile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_progress_handler(arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: - ::std::option::Option - ::std::os::raw::c_int>, - arg4: *mut ::std::os::raw::c_void); + pub fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ); } extern "C" { - pub fn sqlite3_open(filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3) -> ::std::os::raw::c_int; + pub fn sqlite3_open( + filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_open16(filename: *const ::std::os::raw::c_void, - ppDb: *mut *mut sqlite3) -> ::std::os::raw::c_int; + pub fn sqlite3_open16( + filename: *const ::std::os::raw::c_void, + ppDb: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_open_v2(filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3, - flags: ::std::os::raw::c_int, - zVfs: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_open_v2( + filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3, + flags: ::std::os::raw::c_int, + zVfs: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_extended_errcode(db: *mut sqlite3) - -> ::std::os::raw::c_int; + pub fn sqlite3_extended_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_errmsg(arg1: *mut sqlite3) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_errmsg16(arg1: *mut sqlite3) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt([u8; 0]); +pub struct sqlite3_stmt { + _unused: [u8; 0], +} extern "C" { - pub fn sqlite3_limit(arg1: *mut sqlite3, id: ::std::os::raw::c_int, - newVal: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_limit( + arg1: *mut sqlite3, + id: ::std::os::raw::c_int, + newVal: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_prepare( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare_v2(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_prepare_v2( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare16(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_prepare16( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare16_v2(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_prepare16_v2( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct Mem([u8; 0]); +pub struct Mem { + _unused: [u8; 0], +} pub type sqlite3_value = Mem; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_context([u8; 0]); +pub struct sqlite3_context { + _unused: [u8; 0], +} extern "C" { - pub fn sqlite3_bind_blob(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: - ::std::option::Option) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_double(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, arg3: f64) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_int(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_int64(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_int64) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_int64, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_null(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_text(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: - ::std::option::Option) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_text16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: - ::std::option::Option) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_value(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_zeroblob(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - n: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_parameter_name(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_bind_parameter_index(arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_name(arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_name16(arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_database_name(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_database_name16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_table_name(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_table_name16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_origin_name(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_origin_name16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_decltype(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_decltype16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { pub fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_blob(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_bytes(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_bytes16(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) -> f64; + pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64; } extern "C" { - pub fn sqlite3_column_int(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_int64(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) -> sqlite3_int64; + pub fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> sqlite3_int64; } extern "C" { - pub fn sqlite3_column_text(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_uchar; + pub fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar; } extern "C" { - pub fn sqlite3_column_text16(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_type(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_value(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> *mut sqlite3_value; + pub fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value; } extern "C" { - pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_create_function(db: *mut sqlite3, - zFunctionName: - *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: - ::std::option::Option, - xStep: - ::std::option::Option, - xFinal: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function16(db: *mut sqlite3, - zFunctionName: - *const ::std::os::raw::c_void, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: - ::std::option::Option, - xStep: - ::std::option::Option, - xFinal: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) - -> ::std::os::raw::c_int; + pub fn sqlite3_create_function( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function16( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_void, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_transfer_bindings(arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_global_recover() -> ::std::os::raw::c_int; @@ -1019,111 +1474,106 @@ extern "C" { pub fn sqlite3_thread_cleanup(); } extern "C" { - pub fn sqlite3_memory_alarm(arg1: - ::std::option::Option, - arg2: *mut ::std::os::raw::c_void, - arg3: sqlite3_int64) -> ::std::os::raw::c_int; + pub fn sqlite3_memory_alarm( + arg1: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_int64, + arg3: ::std::os::raw::c_int, + ), + >, + arg2: *mut ::std::os::raw::c_void, + arg3: sqlite3_int64, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64; } extern "C" { - pub fn sqlite3_value_int(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite3_int64; } extern "C" { - pub fn sqlite3_value_text(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_uchar; + pub fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar; } extern "C" { - pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_type(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_aggregate_context(arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_user_data(arg1: *mut sqlite3_context) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) - -> *mut sqlite3; + pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3; } extern "C" { - pub fn sqlite3_get_auxdata(arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_set_auxdata(arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - arg3: - ::std::option::Option); + pub fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option, + ); } pub type sqlite3_destructor_type = - ::std::option::Option; + ::std::option::Option; extern "C" { - pub fn sqlite3_result_blob(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); + pub fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); } extern "C" { pub fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64); } extern "C" { - pub fn sqlite3_result_error(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int); + pub fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ); } extern "C" { - pub fn sqlite3_result_error16(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int); + pub fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ); } extern "C" { pub fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context); @@ -1132,270 +1582,556 @@ extern "C" { pub fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context); } extern "C" { - pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int); + pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_result_int(arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int); + pub fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, - arg2: sqlite3_int64); + pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite3_int64); } extern "C" { pub fn sqlite3_result_null(arg1: *mut sqlite3_context); } extern "C" { - pub fn sqlite3_result_text(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); -} -extern "C" { - pub fn sqlite3_result_text16(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); -} -extern "C" { - pub fn sqlite3_result_text16le(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); -} -extern "C" { - pub fn sqlite3_result_text16be(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); -} -extern "C" { - pub fn sqlite3_result_value(arg1: *mut sqlite3_context, - arg2: *mut sqlite3_value); -} -extern "C" { - pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, - n: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_create_collation(arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - xCompare: - ::std::option::Option - ::std::os::raw::c_int>) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation_v2(arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - xCompare: - ::std::option::Option - ::std::os::raw::c_int>, - xDestroy: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation16(arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_void, - eTextRep: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - xCompare: - ::std::option::Option - ::std::os::raw::c_int>) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed(arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed16(arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; -} -extern "C" { - #[link_name = "sqlite3_temp_directory"] + pub fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value); +} +extern "C" { + pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, n: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_create_collation( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation16( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_void, + eTextRep: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "\u{1}sqlite3_temp_directory"] pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) - -> ::std::os::raw::c_int; + pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3; } extern "C" { - pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) - -> *mut sqlite3_stmt; + pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) -> *mut sqlite3_stmt; } extern "C" { - pub fn sqlite3_commit_hook(arg1: *mut sqlite3, - arg2: - ::std::option::Option - ::std::os::raw::c_int>, - arg3: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_rollback_hook(arg1: *mut sqlite3, - arg2: - ::std::option::Option, - arg3: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_update_hook(arg1: *mut sqlite3, - arg2: - ::std::option::Option, - arg3: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_table_column_metadata(db: *mut sqlite3, - zDbName: - *const ::std::os::raw::c_char, - zTableName: - *const ::std::os::raw::c_char, - zColumnName: - *const ::std::os::raw::c_char, - pzDataType: - *mut *const ::std::os::raw::c_char, - pzCollSeq: - *mut *const ::std::os::raw::c_char, - pNotNull: *mut ::std::os::raw::c_int, - pPrimaryKey: - *mut ::std::os::raw::c_int, - pAutoinc: *mut ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_table_column_metadata( + db: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + zTableName: *const ::std::os::raw::c_char, + zColumnName: *const ::std::os::raw::c_char, + pzDataType: *mut *const ::std::os::raw::c_char, + pzCollSeq: *mut *const ::std::os::raw::c_char, + pNotNull: *mut ::std::os::raw::c_int, + pPrimaryKey: *mut ::std::os::raw::c_int, + pAutoinc: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_load_extension(db: *mut sqlite3, - zFile: *const ::std::os::raw::c_char, - zProc: *const ::std::os::raw::c_char, - pzErrMsg: *mut *mut ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_load_extension( + db: *mut sqlite3, + zFile: *const ::std::os::raw::c_char, + zProc: *const ::std::os::raw::c_char, + pzErrMsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_enable_load_extension(db: *mut sqlite3, - onoff: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_enable_load_extension( + db: *mut sqlite3, + onoff: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_auto_extension(xEntryPoint: - ::std::option::Option) - -> ::std::os::raw::c_int; + pub fn sqlite3_auto_extension( + xEntryPoint: ::std::option::Option, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_reset_auto_extension(); } #[repr(C)] -#[derive(Debug, Copy)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, } #[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!(::std::mem::size_of::() , 24usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_vtab { - fn clone(&self) -> Self { *self } +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 160usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_index_info { pub nConstraint: ::std::os::raw::c_int, pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, @@ -1409,7 +2145,7 @@ pub struct sqlite3_index_info { pub estimatedCost: f64, } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_index_info_sqlite3_index_constraint { pub iColumn: ::std::os::raw::c_int, pub op: ::std::os::raw::c_uchar, @@ -1418,275 +2154,458 @@ pub struct sqlite3_index_info_sqlite3_index_constraint { } #[test] fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!(::std::mem::size_of::() - , 12usize); - assert_eq!(::std::mem::align_of::() - , 4usize); -} -impl Clone for sqlite3_index_info_sqlite3_index_constraint { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_index_info_sqlite3_index_orderby { pub iColumn: ::std::os::raw::c_int, pub desc: ::std::os::raw::c_uchar, } #[test] fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!(::std::mem::size_of::() - , 8usize); - assert_eq!(::std::mem::align_of::() - , 4usize); -} -impl Clone for sqlite3_index_info_sqlite3_index_orderby { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_index_info_sqlite3_index_constraint_usage { pub argvIndex: ::std::os::raw::c_int, pub omit: ::std::os::raw::c_uchar, } #[test] fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!(::std::mem::size_of::() - , 8usize); - assert_eq!(::std::mem::align_of::() - , 4usize); -} -impl Clone for sqlite3_index_info_sqlite3_index_constraint_usage { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); } #[test] fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!(::std::mem::size_of::() , 72usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_index_info { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); +} +extern "C" { + pub fn sqlite3_create_module( + db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + p: *const sqlite3_module, + pClientData: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_module_v2( + db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + p: *const sqlite3_module, + pClientData: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy)] -pub struct sqlite3_vtab_cursor { - pub pVtab: *mut sqlite3_vtab, +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, } #[test] -fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!(::std::mem::size_of::() , 8usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_vtab_cursor { - fn clone(&self) -> Self { *self } +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option ::std::os::raw::c_int>, - pub xConnect: ::std::option::Option ::std::os::raw::c_int>, - pub xBestIndex: ::std::option::Option ::std::os::raw::c_int>, - pub xDisconnect: ::std::option::Option ::std::os::raw::c_int>, - pub xDestroy: ::std::option::Option ::std::os::raw::c_int>, - pub xOpen: ::std::option::Option ::std::os::raw::c_int>, - pub xClose: ::std::option::Option ::std::os::raw::c_int>, - pub xFilter: ::std::option::Option ::std::os::raw::c_int>, - pub xNext: ::std::option::Option ::std::os::raw::c_int>, - pub xEof: ::std::option::Option ::std::os::raw::c_int>, - pub xColumn: ::std::option::Option ::std::os::raw::c_int>, - pub xRowid: ::std::option::Option ::std::os::raw::c_int>, - pub xUpdate: ::std::option::Option ::std::os::raw::c_int>, - pub xBegin: ::std::option::Option ::std::os::raw::c_int>, - pub xSync: ::std::option::Option ::std::os::raw::c_int>, - pub xCommit: ::std::option::Option ::std::os::raw::c_int>, - pub xRollback: ::std::option::Option ::std::os::raw::c_int>, - pub xFindFunction: ::std::option::Option, - ppArg: - *mut *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int>, - pub xRename: ::std::option::Option ::std::os::raw::c_int>, +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, } #[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!(::std::mem::size_of::() , 160usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_module { - fn clone(&self) -> Self { *self } -} -extern "C" { - pub fn sqlite3_create_module(db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - p: *const sqlite3_module, - pClientData: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_module_v2(db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - p: *const sqlite3_module, - pClientData: *mut ::std::os::raw::c_void, - xDestroy: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_declare_vtab(arg1: *mut sqlite3, - zSQL: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_overload_function(arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +extern "C" { + pub fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + zSQL: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob([u8; 0]); +pub struct sqlite3_blob { + _unused: [u8; 0], +} extern "C" { - pub fn sqlite3_blob_open(arg1: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - zTable: *const ::std::os::raw::c_char, - zColumn: *const ::std::os::raw::c_char, - iRow: sqlite3_int64, - flags: ::std::os::raw::c_int, - ppBlob: *mut *mut sqlite3_blob) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_open( + arg1: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + zTable: *const ::std::os::raw::c_char, + zColumn: *const ::std::os::raw::c_char, + iRow: sqlite3_int64, + flags: ::std::os::raw::c_int, + ppBlob: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_read(arg1: *mut sqlite3_blob, - Z: *mut ::std::os::raw::c_void, - N: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + Z: *mut ::std::os::raw::c_void, + N: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_write(arg1: *mut sqlite3_blob, - z: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + z: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) - -> *mut sqlite3_vfs; + pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs; } extern "C" { - pub fn sqlite3_vfs_register(arg1: *mut sqlite3_vfs, - makeDflt: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + makeDflt: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) - -> ::std::os::raw::c_int; + pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) - -> *mut sqlite3_mutex; + pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex; } extern "C" { pub fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex); @@ -1695,206 +2614,490 @@ extern "C" { pub fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex); } extern "C" { - pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) - -> ::std::os::raw::c_int; + pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option *mut sqlite3_mutex>, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexNotheld: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, } #[test] fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!(::std::mem::size_of::() , 72usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_mutex_methods { - fn clone(&self) -> Self { *self } -} -extern "C" { - pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) - -> ::std::os::raw::c_int; + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +extern "C" { + pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex; } extern "C" { - pub fn sqlite3_file_control(arg1: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - op: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_file_control( + arg1: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + op: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) - -> ::std::os::raw::c_int; + pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_status(op: ::std::os::raw::c_int, - pCurrent: *mut ::std::os::raw::c_int, - pHighwater: *mut ::std::os::raw::c_int, - resetFlag: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_status( + op: ::std::os::raw::c_int, + pCurrent: *mut ::std::os::raw::c_int, + pHighwater: *mut ::std::os::raw::c_int, + resetFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_db_status(arg1: *mut sqlite3, op: ::std::os::raw::c_int, - pCur: *mut ::std::os::raw::c_int, - pHiwtr: *mut ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_db_status( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + pCur: *mut ::std::os::raw::c_int, + pHiwtr: *mut ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_stmt_status(arg1: *mut sqlite3_stmt, - op: ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_stmt_status( + arg1: *mut sqlite3_stmt, + op: ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache([u8; 0]); +pub struct sqlite3_pcache { + _unused: [u8; 0], +} #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_pcache_methods { pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option ::std::os::raw::c_int>, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option *mut sqlite3_pcache>, - pub xCachesize: ::std::option::Option, - pub xPagecount: ::std::option::Option ::std::os::raw::c_int>, - pub xFetch: ::std::option::Option *mut ::std::os::raw::c_void>, - pub xUnpin: ::std::option::Option, - pub xRekey: ::std::option::Option, - pub xTruncate: ::std::option::Option, - pub xDestroy: ::std::option::Option, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, } #[test] fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!(::std::mem::size_of::() , 88usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_pcache_methods { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_backup([u8; 0]); +pub struct sqlite3_backup { + _unused: [u8; 0], +} extern "C" { - pub fn sqlite3_backup_init(pDest: *mut sqlite3, - zDestName: *const ::std::os::raw::c_char, - pSource: *mut sqlite3, - zSourceName: *const ::std::os::raw::c_char) - -> *mut sqlite3_backup; + pub fn sqlite3_backup_init( + pDest: *mut sqlite3, + zDestName: *const ::std::os::raw::c_char, + pSource: *mut sqlite3, + zSourceName: *const ::std::os::raw::c_char, + ) -> *mut sqlite3_backup; } extern "C" { - pub fn sqlite3_backup_step(p: *mut sqlite3_backup, - nPage: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_backup_step( + p: *mut sqlite3_backup, + nPage: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_backup_finish(p: *mut sqlite3_backup) - -> ::std::os::raw::c_int; + pub fn sqlite3_backup_finish(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_backup_remaining(p: *mut sqlite3_backup) - -> ::std::os::raw::c_int; + pub fn sqlite3_backup_remaining(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_backup_pagecount(p: *mut sqlite3_backup) - -> ::std::os::raw::c_int; + pub fn sqlite3_backup_pagecount(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_unlock_notify(pBlocked: *mut sqlite3, - xNotify: - ::std::option::Option, - pNotifyArg: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_unlock_notify( + pBlocked: *mut sqlite3, + xNotify: ::std::option::Option< + unsafe extern "C" fn( + apArg: *mut *mut ::std::os::raw::c_void, + nArg: ::std::os::raw::c_int, + ), + >, + pNotifyArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_strnicmp(arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_strnicmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_log(iErrCode: ::std::os::raw::c_int, - zFormat: *const ::std::os::raw::c_char, ...); + pub fn sqlite3_log( + iErrCode: ::std::os::raw::c_int, + zFormat: *const ::std::os::raw::c_char, + ... + ); } +pub type __builtin_va_list = [__va_list_tag; 1usize]; #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct __va_list_tag { pub gp_offset: ::std::os::raw::c_uint, pub fp_offset: ::std::os::raw::c_uint, pub overflow_arg_area: *mut ::std::os::raw::c_void, pub reg_save_area: *mut ::std::os::raw::c_void, } -impl Clone for __va_list_tag { - fn clone(&self) -> Self { *self } +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); } -pub type __builtin_va_list = [__va_list_tag; 1usize]; - pub const SQLITE_DETERMINISTIC: i32 = 2048; diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext-embed.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext-embed.rs new file mode 100644 index 000000000..9c4d18f45 --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext-embed.rs @@ -0,0 +1,6833 @@ +/* automatically generated by rust-bindgen */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &'static [u8; 6usize] = b"3.6.8\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3006008; +pub const SQLITE_OK: i32 = 0; +pub const SQLITE_ERROR: i32 = 1; +pub const SQLITE_INTERNAL: i32 = 2; +pub const SQLITE_PERM: i32 = 3; +pub const SQLITE_ABORT: i32 = 4; +pub const SQLITE_BUSY: i32 = 5; +pub const SQLITE_LOCKED: i32 = 6; +pub const SQLITE_NOMEM: i32 = 7; +pub const SQLITE_READONLY: i32 = 8; +pub const SQLITE_INTERRUPT: i32 = 9; +pub const SQLITE_IOERR: i32 = 10; +pub const SQLITE_CORRUPT: i32 = 11; +pub const SQLITE_NOTFOUND: i32 = 12; +pub const SQLITE_FULL: i32 = 13; +pub const SQLITE_CANTOPEN: i32 = 14; +pub const SQLITE_PROTOCOL: i32 = 15; +pub const SQLITE_EMPTY: i32 = 16; +pub const SQLITE_SCHEMA: i32 = 17; +pub const SQLITE_TOOBIG: i32 = 18; +pub const SQLITE_CONSTRAINT: i32 = 19; +pub const SQLITE_MISMATCH: i32 = 20; +pub const SQLITE_MISUSE: i32 = 21; +pub const SQLITE_NOLFS: i32 = 22; +pub const SQLITE_AUTH: i32 = 23; +pub const SQLITE_FORMAT: i32 = 24; +pub const SQLITE_RANGE: i32 = 25; +pub const SQLITE_NOTADB: i32 = 26; +pub const SQLITE_ROW: i32 = 100; +pub const SQLITE_DONE: i32 = 101; +pub const SQLITE_IOERR_READ: i32 = 266; +pub const SQLITE_IOERR_SHORT_READ: i32 = 522; +pub const SQLITE_IOERR_WRITE: i32 = 778; +pub const SQLITE_IOERR_FSYNC: i32 = 1034; +pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; +pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; +pub const SQLITE_IOERR_FSTAT: i32 = 1802; +pub const SQLITE_IOERR_UNLOCK: i32 = 2058; +pub const SQLITE_IOERR_RDLOCK: i32 = 2314; +pub const SQLITE_IOERR_DELETE: i32 = 2570; +pub const SQLITE_IOERR_BLOCKED: i32 = 2826; +pub const SQLITE_IOERR_NOMEM: i32 = 3082; +pub const SQLITE_IOERR_ACCESS: i32 = 3338; +pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; +pub const SQLITE_IOERR_LOCK: i32 = 3850; +pub const SQLITE_IOERR_CLOSE: i32 = 4106; +pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; +pub const SQLITE_OPEN_READONLY: i32 = 1; +pub const SQLITE_OPEN_READWRITE: i32 = 2; +pub const SQLITE_OPEN_CREATE: i32 = 4; +pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; +pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; +pub const SQLITE_OPEN_MAIN_DB: i32 = 256; +pub const SQLITE_OPEN_TEMP_DB: i32 = 512; +pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; +pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; +pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; +pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; +pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; +pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; +pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; +pub const SQLITE_IOCAP_ATOMIC: i32 = 1; +pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; +pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; +pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; +pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; +pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; +pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; +pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; +pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; +pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; +pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; +pub const SQLITE_LOCK_NONE: i32 = 0; +pub const SQLITE_LOCK_SHARED: i32 = 1; +pub const SQLITE_LOCK_RESERVED: i32 = 2; +pub const SQLITE_LOCK_PENDING: i32 = 3; +pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; +pub const SQLITE_SYNC_NORMAL: i32 = 2; +pub const SQLITE_SYNC_FULL: i32 = 3; +pub const SQLITE_SYNC_DATAONLY: i32 = 16; +pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; +pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_LAST_ERRNO: i32 = 4; +pub const SQLITE_ACCESS_EXISTS: i32 = 0; +pub const SQLITE_ACCESS_READWRITE: i32 = 1; +pub const SQLITE_ACCESS_READ: i32 = 2; +pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; +pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; +pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; +pub const SQLITE_CONFIG_MALLOC: i32 = 4; +pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; +pub const SQLITE_CONFIG_SCRATCH: i32 = 6; +pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; +pub const SQLITE_CONFIG_HEAP: i32 = 8; +pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; +pub const SQLITE_CONFIG_MUTEX: i32 = 10; +pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; +pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; +pub const SQLITE_CONFIG_PCACHE: i32 = 14; +pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; +pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; +pub const SQLITE_DENY: i32 = 1; +pub const SQLITE_IGNORE: i32 = 2; +pub const SQLITE_CREATE_INDEX: i32 = 1; +pub const SQLITE_CREATE_TABLE: i32 = 2; +pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; +pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; +pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; +pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; +pub const SQLITE_CREATE_TRIGGER: i32 = 7; +pub const SQLITE_CREATE_VIEW: i32 = 8; +pub const SQLITE_DELETE: i32 = 9; +pub const SQLITE_DROP_INDEX: i32 = 10; +pub const SQLITE_DROP_TABLE: i32 = 11; +pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; +pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; +pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; +pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; +pub const SQLITE_DROP_TRIGGER: i32 = 16; +pub const SQLITE_DROP_VIEW: i32 = 17; +pub const SQLITE_INSERT: i32 = 18; +pub const SQLITE_PRAGMA: i32 = 19; +pub const SQLITE_READ: i32 = 20; +pub const SQLITE_SELECT: i32 = 21; +pub const SQLITE_TRANSACTION: i32 = 22; +pub const SQLITE_UPDATE: i32 = 23; +pub const SQLITE_ATTACH: i32 = 24; +pub const SQLITE_DETACH: i32 = 25; +pub const SQLITE_ALTER_TABLE: i32 = 26; +pub const SQLITE_REINDEX: i32 = 27; +pub const SQLITE_ANALYZE: i32 = 28; +pub const SQLITE_CREATE_VTABLE: i32 = 29; +pub const SQLITE_DROP_VTABLE: i32 = 30; +pub const SQLITE_FUNCTION: i32 = 31; +pub const SQLITE_SAVEPOINT: i32 = 32; +pub const SQLITE_COPY: i32 = 0; +pub const SQLITE_LIMIT_LENGTH: i32 = 0; +pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; +pub const SQLITE_LIMIT_COLUMN: i32 = 2; +pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; +pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; +pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; +pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; +pub const SQLITE_LIMIT_ATTACHED: i32 = 7; +pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; +pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; +pub const SQLITE_INTEGER: i32 = 1; +pub const SQLITE_FLOAT: i32 = 2; +pub const SQLITE_BLOB: i32 = 4; +pub const SQLITE_NULL: i32 = 5; +pub const SQLITE_TEXT: i32 = 3; +pub const SQLITE3_TEXT: i32 = 3; +pub const SQLITE_UTF8: i32 = 1; +pub const SQLITE_UTF16LE: i32 = 2; +pub const SQLITE_UTF16BE: i32 = 3; +pub const SQLITE_UTF16: i32 = 4; +pub const SQLITE_ANY: i32 = 5; +pub const SQLITE_UTF16_ALIGNED: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; +pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; +pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; +pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; +pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; +pub const SQLITE_MUTEX_FAST: i32 = 0; +pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; +pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; +pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; +pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; +pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; +pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; +pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; +pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; +pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; +pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; +pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; +pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; +pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; +pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; +pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; +pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; +pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; +pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; +pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; +pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; +pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; +pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; +pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; +pub const SQLITE_STMTSTATUS_SORT: i32 = 2; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; +extern "C" { + #[link_name = "\u{1}sqlite3_version"] + pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3 { + _unused: [u8; 0], +} +pub type sqlite_int64 = ::std::os::raw::c_longlong; +pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; +pub type sqlite3_int64 = sqlite_int64; +pub type sqlite3_uint64 = sqlite_uint64; +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_file { + pub pMethods: *const sqlite3_io_methods, +} +#[test] +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vfs { + pub iVersion: ::std::os::raw::c_int, + pub szOsFile: ::std::os::raw::c_int, + pub mxPathname: ::std::os::raw::c_int, + pub pNext: *mut sqlite3_vfs, + pub zName: *const ::std::os::raw::c_char, + pub pAppData: *mut ::std::os::raw::c_void, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_vfs() { + assert_eq!( + ::std::mem::size_of::(), + 136usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mem_methods { + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub pAppData: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_mem_methods() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_stmt { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Mem { + _unused: [u8; 0], +} +pub type sqlite3_value = Mem; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_context { + _unused: [u8; 0], +} +pub type sqlite3_destructor_type = + ::std::option::Option; +extern "C" { + #[link_name = "\u{1}sqlite3_temp_directory"] + pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 160usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info { + pub nConstraint: ::std::os::raw::c_int, + pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, + pub nOrderBy: ::std::os::raw::c_int, + pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, + pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, + pub idxNum: ::std::os::raw::c_int, + pub idxStr: *mut ::std::os::raw::c_char, + pub needToFreeIdxStr: ::std::os::raw::c_int, + pub orderByConsumed: ::std::os::raw::c_int, + pub estimatedCost: f64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint { + pub iColumn: ::std::os::raw::c_int, + pub op: ::std::os::raw::c_uchar, + pub usable: ::std::os::raw::c_uchar, + pub iTermOffset: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_orderby { + pub iColumn: ::std::os::raw::c_int, + pub desc: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint_usage { + pub argvIndex: ::std::os::raw::c_int, + pub omit: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); +} +#[test] +fn bindgen_test_layout_sqlite3_index_info() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_blob { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex_methods { + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_mutex_methods() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods { + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_api_routines { + pub aggregate_context: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub aggregate_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, + >, + pub bind_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_double: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int, + >, + pub bind_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, + ) -> ::std::os::raw::c_int, + >, + pub bind_null: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub bind_parameter_index: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub bind_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub busy_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub busy_timeout: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub changes: + ::std::option::Option ::std::os::raw::c_int>, + pub close: + ::std::option::Option ::std::os::raw::c_int>, + pub collation_needed: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub collation_needed16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub column_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_bytes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_bytes16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub column_database_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_database_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_decltype: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_decltype16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_double: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, + >, + pub column_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_int64: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, + >, + pub column_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_origin_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_origin_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_table_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_table_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar, + >, + pub column_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_type: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value, + >, + pub commit_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub complete: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub complete16: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub create_collation: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_collation16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_function16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_module: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub data_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub db_handle: + ::std::option::Option *mut sqlite3>, + pub declare_vtab: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub enable_shared_cache: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub errmsg: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, + >, + pub errmsg16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, + >, + pub exec: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub expired: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub finalize: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub free: ::std::option::Option, + pub free_table: + ::std::option::Option, + pub get_autocommit: + ::std::option::Option ::std::os::raw::c_int>, + pub get_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub get_table: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub global_recover: ::std::option::Option ::std::os::raw::c_int>, + pub interruptx: ::std::option::Option, + pub last_insert_rowid: + ::std::option::Option sqlite_int64>, + pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, + pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, + pub malloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub mprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub open16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub prepare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub profile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub progress_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ), + >, + pub realloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub result_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_double: + ::std::option::Option, + pub result_error: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_error16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_int64: + ::std::option::Option, + pub result_null: ::std::option::Option, + pub result_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16be: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16le: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_value: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), + >, + pub rollback_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub set_authorizer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub set_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, + ), + >, + pub snprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub step: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub table_column_metadata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub thread_cleanup: ::std::option::Option, + pub total_changes: + ::std::option::Option ::std::os::raw::c_int>, + pub trace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub transfer_bindings: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int, + >, + pub update_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub user_data: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, + >, + pub value_blob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_bytes16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_double: ::std::option::Option f64>, + pub value_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_int64: + ::std::option::Option sqlite_int64>, + pub value_numeric_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_text: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, + >, + pub value_text16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16be: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16le: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub vmprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub overload_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub prepare_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub clear_bindings: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub create_module_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_close: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int, + >, + pub blob_read: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_write: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub create_collation_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub file_control: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub memory_highwater: + ::std::option::Option sqlite3_int64>, + pub memory_used: ::std::option::Option sqlite3_int64>, + pub mutex_alloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub mutex_enter: ::std::option::Option, + pub mutex_free: ::std::option::Option, + pub mutex_leave: ::std::option::Option, + pub mutex_try: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub open_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub release_memory: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub result_error_nomem: ::std::option::Option, + pub result_error_toobig: + ::std::option::Option, + pub sleep: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub soft_heap_limit: ::std::option::Option, + pub vfs_find: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, + >, + pub vfs_register: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub vfs_unregister: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, + >, + pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, + pub result_zeroblob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_error_code: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub test_control: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, + >, + pub randomness: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), + >, + pub context_db_handle: + ::std::option::Option *mut sqlite3>, + pub extended_result_codes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub limit: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub next_stmt: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, + >, + pub sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, + >, + pub status: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_api_routines() { + assert_eq!( + ::std::mem::size_of::(), + 1240usize, + concat!("Size of: ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_context as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_context) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_count as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_double as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_count as *const _ + as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_index as *const _ + as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_index) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_name as *const _ + as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text16 as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_handler as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_handler) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_timeout as *const _ as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_timeout) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed as *const _ as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_blob as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes as *const _ as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize + }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_count as *const _ as usize + }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name as *const _ + as usize + }, + 184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name16 as *const _ + as usize + }, + 192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype as *const _ as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize + }, + 208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_double as *const _ as usize + }, + 216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, + 224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_int64 as *const _ as usize + }, + 232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name as *const _ as usize + }, + 240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name16 as *const _ as usize + }, + 248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name as *const _ as usize + }, + 256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name16 as *const _ + as usize + }, + 264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name as *const _ as usize + }, + 272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name16 as *const _ + as usize + }, + 280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text as *const _ as usize + }, + 288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text16 as *const _ as usize + }, + 296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_type as *const _ as usize + }, + 304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_type) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_value as *const _ as usize + }, + 312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).commit_hook as *const _ as usize + }, + 320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(commit_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, + 328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, + 336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation as *const _ as usize + }, + 344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation16 as *const _ as usize + }, + 352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function as *const _ as usize + }, + 360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function16 as *const _ as usize + }, + 368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module as *const _ as usize + }, + 376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, + 384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(data_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, + 392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).declare_vtab as *const _ as usize + }, + 400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(declare_vtab) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).enable_shared_cache as *const _ + as usize + }, + 408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(enable_shared_cache) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, + 416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, + 424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, + 432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, + 440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(exec) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, + 448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(expired) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, + 456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(finalize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, + 464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, + 472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_autocommit as *const _ as usize + }, + 480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_autocommit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_auxdata as *const _ as usize + }, + 488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, + 496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).global_recover as *const _ as usize + }, + 504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(global_recover) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, + 512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(interruptx) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize + }, + 520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(last_insert_rowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, + 528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).libversion_number as *const _ as usize + }, + 536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion_number) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, + 544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, + 552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, + 560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, + 568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, + 576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, + 584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, + 592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(profile) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).progress_handler as *const _ as usize + }, + 600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(progress_handler) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, + 608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, + 616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob as *const _ as usize + }, + 624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_double as *const _ as usize + }, + 632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_double) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error as *const _ as usize + }, + 640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error16 as *const _ as usize + }, + 648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, + 656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_int64 as *const _ as usize + }, + 664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_null as *const _ as usize + }, + 672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text as *const _ as usize + }, + 680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16 as *const _ as usize + }, + 688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16be as *const _ as usize + }, + 696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16le as *const _ as usize + }, + 704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16le) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_value as *const _ as usize + }, + 712usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rollback_hook as *const _ as usize + }, + 720usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(rollback_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_authorizer as *const _ as usize + }, + 728usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_authorizer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_auxdata as *const _ as usize + }, + 736usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).snprintf as *const _ as usize }, + 744usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(snprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, + 752usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).table_column_metadata as *const _ + as usize + }, + 760usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(table_column_metadata) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize + }, + 768usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(thread_cleanup) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).total_changes as *const _ as usize + }, + 776usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(total_changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, + 784usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(trace) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize + }, + 792usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(transfer_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).update_hook as *const _ as usize + }, + 800usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(update_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, + 808usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(user_data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, + 816usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes as *const _ as usize + }, + 824usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize + }, + 832usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_double as *const _ as usize + }, + 840usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, + 848usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_int64 as *const _ as usize + }, + 856usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize + }, + 864usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_numeric_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, + 872usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16 as *const _ as usize + }, + 880usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16be as *const _ as usize + }, + 888usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16le as *const _ as usize + }, + 896usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16le) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, + 904usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, + 912usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vmprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).overload_function as *const _ as usize + }, + 920usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(overload_function) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, + 928usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize + }, + 936usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).clear_bindings as *const _ as usize + }, + 944usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(clear_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize + }, + 952usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize + }, + 960usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, + 968usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_bytes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, + 976usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_close) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, + 984usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, + 992usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_read) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, + 1000usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_write) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation_v2 as *const _ + as usize + }, + 1008usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).file_control as *const _ as usize + }, + 1016usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(file_control) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_highwater as *const _ as usize + }, + 1024usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_highwater) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_used as *const _ as usize + }, + 1032usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize + }, + 1040usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_alloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_enter as *const _ as usize + }, + 1048usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_enter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, + 1056usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_leave as *const _ as usize + }, + 1064usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_leave) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, + 1072usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_try) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, + 1080usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).release_memory as *const _ as usize + }, + 1088usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(release_memory) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize + }, + 1096usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_nomem) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_toobig as *const _ + as usize + }, + 1104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_toobig) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, + 1112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sleep) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize + }, + 1120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, + 1128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_find) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_register as *const _ as usize + }, + 1136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_register) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize + }, + 1144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_unregister) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize + }, + 1152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xthreadsafe) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize + }, + 1160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_code as *const _ as usize + }, + 1168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_code) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).test_control as *const _ as usize + }, + 1176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(test_control) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, + 1184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(randomness) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).context_db_handle as *const _ as usize + }, + 1192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(context_db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_result_codes as *const _ + as usize + }, + 1200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_result_codes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, + 1208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, + 1216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(next_stmt) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, + 1224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sql) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, + 1232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status) + ) + ); +} +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} + +// bindings were built with loadable_extension_embedded: +// define sqlite3_api as an extern since this code will be embedded +// within a loadable extension that defines and exports this itself +extern "C" { + #[no_mangle] + pub static mut sqlite3_api: *mut sqlite3_api_routines; +} + +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) + +pub unsafe fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_context.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_context", + " function" + )))(arg1, nBytes) +} + +pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_double", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_null", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_index.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_index", + " function" + )))(arg1, zName) +} + +pub unsafe fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_value", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_handler", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_timeout.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_timeout", + " function" + )))(arg1, ms) +} + +pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_blob", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype", + " function" + )))(arg1, i) +} + +pub unsafe fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_double", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int64", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_type", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_value", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).commit_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "commit_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete16", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_create_collation( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_collation16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_function( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_function16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function16", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_module( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).data_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "data_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).declare_vtab.expect(stringify!( + "sqlite3_api contains null pointer for ", + "declare_vtab", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).enable_shared_cache.expect(stringify!( + "sqlite3_api contains null pointer for ", + "enable_shared_cache", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errcode", + " function" + )))(db) +} + +pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_exec( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).exec.expect(stringify!( + "sqlite3_api contains null pointer for ", + "exec", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).expired.expect(stringify!( + "sqlite3_api contains null pointer for ", + "expired", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).finalize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "finalize", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free_table", + " function" + )))(result) +} + +pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_autocommit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_autocommit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_auxdata", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_get_table( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_table", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).global_recover.expect(stringify!( + "sqlite3_api contains null pointer for ", + "global_recover", + " function" + )))() +} + +pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).interruptx.expect(stringify!( + "sqlite3_api contains null pointer for ", + "interruptx", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).last_insert_rowid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "last_insert_rowid", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion", + " function" + )))() +} + +pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion_number.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion_number", + " function" + )))() +} + +pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mprintf( + arg1: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mprintf", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_open( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_open16( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_prepare( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_profile( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).profile.expect(stringify!( + "sqlite3_api contains null pointer for ", + "profile", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).progress_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "progress_handler", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_double", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_null", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16be", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16le", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_value", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).rollback_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "rollback_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_authorizer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_authorizer", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_auxdata", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_snprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).snprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "snprintf", + " function" + )))(arg1, arg2, arg3, vararg1) +} + +pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "step", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_table_column_metadata( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).table_column_metadata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "table_column_metadata", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) +} + +pub unsafe fn sqlite3_thread_cleanup() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).thread_cleanup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "thread_cleanup", + " function" + )))() +} + +pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).total_changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "total_changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).trace.expect(stringify!( + "sqlite3_api contains null pointer for ", + "trace", + " function" + )))(arg1, xTrace, arg2) +} + +pub unsafe fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).transfer_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "transfer_bindings", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).update_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "update_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).user_data.expect(stringify!( + "sqlite3_api contains null pointer for ", + "user_data", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_blob", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_double", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_numeric_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_numeric_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16be", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16le", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vmprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vmprintf", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).overload_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "overload_function", + " function" + )))(arg1, zFuncName, nArg) +} + +pub unsafe fn sqlite3_prepare_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).clear_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "clear_bindings", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_module_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module_v2", + " function" + )))(arg1, arg2, arg3, arg4, xDestroy) +} + +pub unsafe fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_open( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_open", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) +} + +pub unsafe fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_read.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_read", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_write.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_write", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_file_control( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).file_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "file_control", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_highwater.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_highwater", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_used", + " function" + )))() +} + +pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_alloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_alloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_enter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_enter", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_leave.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_leave", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_try.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_try", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_open_v2( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open_v2", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_nomem.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_nomem", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_toobig.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_toobig", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sleep.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sleep", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_find.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_find", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_register.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_register", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_unregister.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_unregister", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xthreadsafe.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xthreadsafe", + " function" + )))() +} + +pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_code.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_code", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_test_control( + arg1: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).test_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "test_control", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).randomness.expect(stringify!( + "sqlite3_api contains null pointer for ", + "randomness", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).context_db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "context_db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_result_codes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_result_codes", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_limit( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "limit", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).next_stmt.expect(stringify!( + "sqlite3_api contains null pointer for ", + "next_stmt", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_status( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub const SQLITE_DETERMINISTIC: i32 = 2048; diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs new file mode 100644 index 000000000..91f24f7a5 --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs @@ -0,0 +1,6831 @@ +/* automatically generated by rust-bindgen */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &'static [u8; 6usize] = b"3.6.8\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3006008; +pub const SQLITE_OK: i32 = 0; +pub const SQLITE_ERROR: i32 = 1; +pub const SQLITE_INTERNAL: i32 = 2; +pub const SQLITE_PERM: i32 = 3; +pub const SQLITE_ABORT: i32 = 4; +pub const SQLITE_BUSY: i32 = 5; +pub const SQLITE_LOCKED: i32 = 6; +pub const SQLITE_NOMEM: i32 = 7; +pub const SQLITE_READONLY: i32 = 8; +pub const SQLITE_INTERRUPT: i32 = 9; +pub const SQLITE_IOERR: i32 = 10; +pub const SQLITE_CORRUPT: i32 = 11; +pub const SQLITE_NOTFOUND: i32 = 12; +pub const SQLITE_FULL: i32 = 13; +pub const SQLITE_CANTOPEN: i32 = 14; +pub const SQLITE_PROTOCOL: i32 = 15; +pub const SQLITE_EMPTY: i32 = 16; +pub const SQLITE_SCHEMA: i32 = 17; +pub const SQLITE_TOOBIG: i32 = 18; +pub const SQLITE_CONSTRAINT: i32 = 19; +pub const SQLITE_MISMATCH: i32 = 20; +pub const SQLITE_MISUSE: i32 = 21; +pub const SQLITE_NOLFS: i32 = 22; +pub const SQLITE_AUTH: i32 = 23; +pub const SQLITE_FORMAT: i32 = 24; +pub const SQLITE_RANGE: i32 = 25; +pub const SQLITE_NOTADB: i32 = 26; +pub const SQLITE_ROW: i32 = 100; +pub const SQLITE_DONE: i32 = 101; +pub const SQLITE_IOERR_READ: i32 = 266; +pub const SQLITE_IOERR_SHORT_READ: i32 = 522; +pub const SQLITE_IOERR_WRITE: i32 = 778; +pub const SQLITE_IOERR_FSYNC: i32 = 1034; +pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; +pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; +pub const SQLITE_IOERR_FSTAT: i32 = 1802; +pub const SQLITE_IOERR_UNLOCK: i32 = 2058; +pub const SQLITE_IOERR_RDLOCK: i32 = 2314; +pub const SQLITE_IOERR_DELETE: i32 = 2570; +pub const SQLITE_IOERR_BLOCKED: i32 = 2826; +pub const SQLITE_IOERR_NOMEM: i32 = 3082; +pub const SQLITE_IOERR_ACCESS: i32 = 3338; +pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; +pub const SQLITE_IOERR_LOCK: i32 = 3850; +pub const SQLITE_IOERR_CLOSE: i32 = 4106; +pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; +pub const SQLITE_OPEN_READONLY: i32 = 1; +pub const SQLITE_OPEN_READWRITE: i32 = 2; +pub const SQLITE_OPEN_CREATE: i32 = 4; +pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; +pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; +pub const SQLITE_OPEN_MAIN_DB: i32 = 256; +pub const SQLITE_OPEN_TEMP_DB: i32 = 512; +pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; +pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; +pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; +pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; +pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; +pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; +pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; +pub const SQLITE_IOCAP_ATOMIC: i32 = 1; +pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; +pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; +pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; +pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; +pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; +pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; +pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; +pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; +pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; +pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; +pub const SQLITE_LOCK_NONE: i32 = 0; +pub const SQLITE_LOCK_SHARED: i32 = 1; +pub const SQLITE_LOCK_RESERVED: i32 = 2; +pub const SQLITE_LOCK_PENDING: i32 = 3; +pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; +pub const SQLITE_SYNC_NORMAL: i32 = 2; +pub const SQLITE_SYNC_FULL: i32 = 3; +pub const SQLITE_SYNC_DATAONLY: i32 = 16; +pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; +pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_LAST_ERRNO: i32 = 4; +pub const SQLITE_ACCESS_EXISTS: i32 = 0; +pub const SQLITE_ACCESS_READWRITE: i32 = 1; +pub const SQLITE_ACCESS_READ: i32 = 2; +pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; +pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; +pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; +pub const SQLITE_CONFIG_MALLOC: i32 = 4; +pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; +pub const SQLITE_CONFIG_SCRATCH: i32 = 6; +pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; +pub const SQLITE_CONFIG_HEAP: i32 = 8; +pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; +pub const SQLITE_CONFIG_MUTEX: i32 = 10; +pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; +pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; +pub const SQLITE_CONFIG_PCACHE: i32 = 14; +pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; +pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; +pub const SQLITE_DENY: i32 = 1; +pub const SQLITE_IGNORE: i32 = 2; +pub const SQLITE_CREATE_INDEX: i32 = 1; +pub const SQLITE_CREATE_TABLE: i32 = 2; +pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; +pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; +pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; +pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; +pub const SQLITE_CREATE_TRIGGER: i32 = 7; +pub const SQLITE_CREATE_VIEW: i32 = 8; +pub const SQLITE_DELETE: i32 = 9; +pub const SQLITE_DROP_INDEX: i32 = 10; +pub const SQLITE_DROP_TABLE: i32 = 11; +pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; +pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; +pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; +pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; +pub const SQLITE_DROP_TRIGGER: i32 = 16; +pub const SQLITE_DROP_VIEW: i32 = 17; +pub const SQLITE_INSERT: i32 = 18; +pub const SQLITE_PRAGMA: i32 = 19; +pub const SQLITE_READ: i32 = 20; +pub const SQLITE_SELECT: i32 = 21; +pub const SQLITE_TRANSACTION: i32 = 22; +pub const SQLITE_UPDATE: i32 = 23; +pub const SQLITE_ATTACH: i32 = 24; +pub const SQLITE_DETACH: i32 = 25; +pub const SQLITE_ALTER_TABLE: i32 = 26; +pub const SQLITE_REINDEX: i32 = 27; +pub const SQLITE_ANALYZE: i32 = 28; +pub const SQLITE_CREATE_VTABLE: i32 = 29; +pub const SQLITE_DROP_VTABLE: i32 = 30; +pub const SQLITE_FUNCTION: i32 = 31; +pub const SQLITE_SAVEPOINT: i32 = 32; +pub const SQLITE_COPY: i32 = 0; +pub const SQLITE_LIMIT_LENGTH: i32 = 0; +pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; +pub const SQLITE_LIMIT_COLUMN: i32 = 2; +pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; +pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; +pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; +pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; +pub const SQLITE_LIMIT_ATTACHED: i32 = 7; +pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; +pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; +pub const SQLITE_INTEGER: i32 = 1; +pub const SQLITE_FLOAT: i32 = 2; +pub const SQLITE_BLOB: i32 = 4; +pub const SQLITE_NULL: i32 = 5; +pub const SQLITE_TEXT: i32 = 3; +pub const SQLITE3_TEXT: i32 = 3; +pub const SQLITE_UTF8: i32 = 1; +pub const SQLITE_UTF16LE: i32 = 2; +pub const SQLITE_UTF16BE: i32 = 3; +pub const SQLITE_UTF16: i32 = 4; +pub const SQLITE_ANY: i32 = 5; +pub const SQLITE_UTF16_ALIGNED: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; +pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; +pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; +pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; +pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; +pub const SQLITE_MUTEX_FAST: i32 = 0; +pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; +pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; +pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; +pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; +pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; +pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; +pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; +pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; +pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; +pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; +pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; +pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; +pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; +pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; +pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; +pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; +pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; +pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; +pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; +pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; +pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; +pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; +pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; +pub const SQLITE_STMTSTATUS_SORT: i32 = 2; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; +extern "C" { + #[link_name = "\u{1}sqlite3_version"] + pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3 { + _unused: [u8; 0], +} +pub type sqlite_int64 = ::std::os::raw::c_longlong; +pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; +pub type sqlite3_int64 = sqlite_int64; +pub type sqlite3_uint64 = sqlite_uint64; +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_file { + pub pMethods: *const sqlite3_io_methods, +} +#[test] +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vfs { + pub iVersion: ::std::os::raw::c_int, + pub szOsFile: ::std::os::raw::c_int, + pub mxPathname: ::std::os::raw::c_int, + pub pNext: *mut sqlite3_vfs, + pub zName: *const ::std::os::raw::c_char, + pub pAppData: *mut ::std::os::raw::c_void, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_vfs() { + assert_eq!( + ::std::mem::size_of::(), + 136usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mem_methods { + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub pAppData: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_mem_methods() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_stmt { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Mem { + _unused: [u8; 0], +} +pub type sqlite3_value = Mem; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_context { + _unused: [u8; 0], +} +pub type sqlite3_destructor_type = + ::std::option::Option; +extern "C" { + #[link_name = "\u{1}sqlite3_temp_directory"] + pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 160usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info { + pub nConstraint: ::std::os::raw::c_int, + pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, + pub nOrderBy: ::std::os::raw::c_int, + pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, + pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, + pub idxNum: ::std::os::raw::c_int, + pub idxStr: *mut ::std::os::raw::c_char, + pub needToFreeIdxStr: ::std::os::raw::c_int, + pub orderByConsumed: ::std::os::raw::c_int, + pub estimatedCost: f64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint { + pub iColumn: ::std::os::raw::c_int, + pub op: ::std::os::raw::c_uchar, + pub usable: ::std::os::raw::c_uchar, + pub iTermOffset: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_orderby { + pub iColumn: ::std::os::raw::c_int, + pub desc: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint_usage { + pub argvIndex: ::std::os::raw::c_int, + pub omit: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); +} +#[test] +fn bindgen_test_layout_sqlite3_index_info() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_blob { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex_methods { + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_mutex_methods() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods { + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_api_routines { + pub aggregate_context: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub aggregate_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, + >, + pub bind_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_double: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int, + >, + pub bind_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, + ) -> ::std::os::raw::c_int, + >, + pub bind_null: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub bind_parameter_index: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub bind_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub busy_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub busy_timeout: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub changes: + ::std::option::Option ::std::os::raw::c_int>, + pub close: + ::std::option::Option ::std::os::raw::c_int>, + pub collation_needed: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub collation_needed16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub column_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_bytes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_bytes16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub column_database_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_database_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_decltype: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_decltype16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_double: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, + >, + pub column_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_int64: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, + >, + pub column_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_origin_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_origin_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_table_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_table_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar, + >, + pub column_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_type: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value, + >, + pub commit_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub complete: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub complete16: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub create_collation: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_collation16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_function16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_module: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub data_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub db_handle: + ::std::option::Option *mut sqlite3>, + pub declare_vtab: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub enable_shared_cache: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub errmsg: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, + >, + pub errmsg16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, + >, + pub exec: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub expired: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub finalize: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub free: ::std::option::Option, + pub free_table: + ::std::option::Option, + pub get_autocommit: + ::std::option::Option ::std::os::raw::c_int>, + pub get_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub get_table: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub global_recover: ::std::option::Option ::std::os::raw::c_int>, + pub interruptx: ::std::option::Option, + pub last_insert_rowid: + ::std::option::Option sqlite_int64>, + pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, + pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, + pub malloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub mprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub open16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub prepare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub profile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub progress_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ), + >, + pub realloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub result_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_double: + ::std::option::Option, + pub result_error: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_error16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_int64: + ::std::option::Option, + pub result_null: ::std::option::Option, + pub result_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16be: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16le: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_value: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), + >, + pub rollback_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub set_authorizer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub set_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, + ), + >, + pub snprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub step: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub table_column_metadata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub thread_cleanup: ::std::option::Option, + pub total_changes: + ::std::option::Option ::std::os::raw::c_int>, + pub trace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub transfer_bindings: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int, + >, + pub update_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub user_data: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, + >, + pub value_blob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_bytes16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_double: ::std::option::Option f64>, + pub value_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_int64: + ::std::option::Option sqlite_int64>, + pub value_numeric_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_text: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, + >, + pub value_text16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16be: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16le: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub vmprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub overload_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub prepare_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub clear_bindings: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub create_module_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_close: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int, + >, + pub blob_read: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_write: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub create_collation_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub file_control: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub memory_highwater: + ::std::option::Option sqlite3_int64>, + pub memory_used: ::std::option::Option sqlite3_int64>, + pub mutex_alloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub mutex_enter: ::std::option::Option, + pub mutex_free: ::std::option::Option, + pub mutex_leave: ::std::option::Option, + pub mutex_try: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub open_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub release_memory: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub result_error_nomem: ::std::option::Option, + pub result_error_toobig: + ::std::option::Option, + pub sleep: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub soft_heap_limit: ::std::option::Option, + pub vfs_find: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, + >, + pub vfs_register: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub vfs_unregister: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, + >, + pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, + pub result_zeroblob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_error_code: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub test_control: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, + >, + pub randomness: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), + >, + pub context_db_handle: + ::std::option::Option *mut sqlite3>, + pub extended_result_codes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub limit: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub next_stmt: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, + >, + pub sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, + >, + pub status: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_api_routines() { + assert_eq!( + ::std::mem::size_of::(), + 1240usize, + concat!("Size of: ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_context as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_context) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_count as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_double as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_count as *const _ + as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_index as *const _ + as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_index) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_name as *const _ + as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text16 as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_handler as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_handler) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_timeout as *const _ as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_timeout) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed as *const _ as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_blob as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes as *const _ as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize + }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_count as *const _ as usize + }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name as *const _ + as usize + }, + 184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name16 as *const _ + as usize + }, + 192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype as *const _ as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize + }, + 208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_double as *const _ as usize + }, + 216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, + 224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_int64 as *const _ as usize + }, + 232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name as *const _ as usize + }, + 240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name16 as *const _ as usize + }, + 248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name as *const _ as usize + }, + 256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name16 as *const _ + as usize + }, + 264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name as *const _ as usize + }, + 272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name16 as *const _ + as usize + }, + 280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text as *const _ as usize + }, + 288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text16 as *const _ as usize + }, + 296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_type as *const _ as usize + }, + 304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_type) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_value as *const _ as usize + }, + 312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).commit_hook as *const _ as usize + }, + 320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(commit_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, + 328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, + 336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation as *const _ as usize + }, + 344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation16 as *const _ as usize + }, + 352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function as *const _ as usize + }, + 360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function16 as *const _ as usize + }, + 368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module as *const _ as usize + }, + 376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, + 384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(data_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, + 392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).declare_vtab as *const _ as usize + }, + 400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(declare_vtab) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).enable_shared_cache as *const _ + as usize + }, + 408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(enable_shared_cache) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, + 416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, + 424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, + 432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, + 440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(exec) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, + 448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(expired) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, + 456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(finalize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, + 464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, + 472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_autocommit as *const _ as usize + }, + 480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_autocommit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_auxdata as *const _ as usize + }, + 488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, + 496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).global_recover as *const _ as usize + }, + 504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(global_recover) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, + 512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(interruptx) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize + }, + 520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(last_insert_rowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, + 528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).libversion_number as *const _ as usize + }, + 536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion_number) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, + 544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, + 552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, + 560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, + 568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, + 576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, + 584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, + 592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(profile) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).progress_handler as *const _ as usize + }, + 600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(progress_handler) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, + 608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, + 616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob as *const _ as usize + }, + 624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_double as *const _ as usize + }, + 632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_double) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error as *const _ as usize + }, + 640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error16 as *const _ as usize + }, + 648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, + 656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_int64 as *const _ as usize + }, + 664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_null as *const _ as usize + }, + 672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text as *const _ as usize + }, + 680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16 as *const _ as usize + }, + 688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16be as *const _ as usize + }, + 696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16le as *const _ as usize + }, + 704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16le) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_value as *const _ as usize + }, + 712usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rollback_hook as *const _ as usize + }, + 720usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(rollback_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_authorizer as *const _ as usize + }, + 728usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_authorizer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_auxdata as *const _ as usize + }, + 736usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).snprintf as *const _ as usize }, + 744usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(snprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, + 752usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).table_column_metadata as *const _ + as usize + }, + 760usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(table_column_metadata) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize + }, + 768usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(thread_cleanup) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).total_changes as *const _ as usize + }, + 776usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(total_changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, + 784usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(trace) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize + }, + 792usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(transfer_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).update_hook as *const _ as usize + }, + 800usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(update_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, + 808usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(user_data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, + 816usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes as *const _ as usize + }, + 824usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize + }, + 832usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_double as *const _ as usize + }, + 840usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, + 848usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_int64 as *const _ as usize + }, + 856usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize + }, + 864usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_numeric_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, + 872usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16 as *const _ as usize + }, + 880usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16be as *const _ as usize + }, + 888usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16le as *const _ as usize + }, + 896usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16le) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, + 904usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, + 912usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vmprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).overload_function as *const _ as usize + }, + 920usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(overload_function) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, + 928usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize + }, + 936usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).clear_bindings as *const _ as usize + }, + 944usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(clear_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize + }, + 952usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize + }, + 960usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, + 968usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_bytes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, + 976usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_close) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, + 984usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, + 992usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_read) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, + 1000usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_write) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation_v2 as *const _ + as usize + }, + 1008usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).file_control as *const _ as usize + }, + 1016usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(file_control) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_highwater as *const _ as usize + }, + 1024usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_highwater) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_used as *const _ as usize + }, + 1032usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize + }, + 1040usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_alloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_enter as *const _ as usize + }, + 1048usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_enter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, + 1056usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_leave as *const _ as usize + }, + 1064usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_leave) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, + 1072usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_try) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, + 1080usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).release_memory as *const _ as usize + }, + 1088usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(release_memory) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize + }, + 1096usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_nomem) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_toobig as *const _ + as usize + }, + 1104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_toobig) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, + 1112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sleep) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize + }, + 1120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, + 1128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_find) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_register as *const _ as usize + }, + 1136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_register) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize + }, + 1144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_unregister) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize + }, + 1152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xthreadsafe) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize + }, + 1160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_code as *const _ as usize + }, + 1168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_code) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).test_control as *const _ as usize + }, + 1176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(test_control) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, + 1184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(randomness) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).context_db_handle as *const _ as usize + }, + 1192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(context_db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_result_codes as *const _ + as usize + }, + 1200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_result_codes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, + 1208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, + 1216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(next_stmt) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, + 1224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sql) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, + 1232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status) + ) + ); +} +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} + +// bindings were built with (non-embedded) loadable_extension: +// we define our own sqlite_api static variable and export it +// to C +#[no_mangle] +pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_routines; + +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) + +pub unsafe fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_context.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_context", + " function" + )))(arg1, nBytes) +} + +pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_double", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_null", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_index.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_index", + " function" + )))(arg1, zName) +} + +pub unsafe fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_value", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_handler", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_timeout.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_timeout", + " function" + )))(arg1, ms) +} + +pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_blob", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype", + " function" + )))(arg1, i) +} + +pub unsafe fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_double", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int64", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_type", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_value", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).commit_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "commit_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete16", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_create_collation( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_collation16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_function( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_function16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function16", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_module( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).data_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "data_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).declare_vtab.expect(stringify!( + "sqlite3_api contains null pointer for ", + "declare_vtab", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).enable_shared_cache.expect(stringify!( + "sqlite3_api contains null pointer for ", + "enable_shared_cache", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errcode", + " function" + )))(db) +} + +pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_exec( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).exec.expect(stringify!( + "sqlite3_api contains null pointer for ", + "exec", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).expired.expect(stringify!( + "sqlite3_api contains null pointer for ", + "expired", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).finalize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "finalize", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free_table", + " function" + )))(result) +} + +pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_autocommit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_autocommit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_auxdata", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_get_table( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_table", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).global_recover.expect(stringify!( + "sqlite3_api contains null pointer for ", + "global_recover", + " function" + )))() +} + +pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).interruptx.expect(stringify!( + "sqlite3_api contains null pointer for ", + "interruptx", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).last_insert_rowid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "last_insert_rowid", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion", + " function" + )))() +} + +pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion_number.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion_number", + " function" + )))() +} + +pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mprintf( + arg1: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mprintf", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_open( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_open16( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_prepare( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_profile( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).profile.expect(stringify!( + "sqlite3_api contains null pointer for ", + "profile", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).progress_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "progress_handler", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_double", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_null", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16be", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16le", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_value", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).rollback_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "rollback_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_authorizer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_authorizer", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_auxdata", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_snprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).snprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "snprintf", + " function" + )))(arg1, arg2, arg3, vararg1) +} + +pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "step", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_table_column_metadata( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).table_column_metadata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "table_column_metadata", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) +} + +pub unsafe fn sqlite3_thread_cleanup() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).thread_cleanup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "thread_cleanup", + " function" + )))() +} + +pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).total_changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "total_changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).trace.expect(stringify!( + "sqlite3_api contains null pointer for ", + "trace", + " function" + )))(arg1, xTrace, arg2) +} + +pub unsafe fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).transfer_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "transfer_bindings", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).update_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "update_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).user_data.expect(stringify!( + "sqlite3_api contains null pointer for ", + "user_data", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_blob", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_double", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_numeric_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_numeric_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16be", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16le", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vmprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vmprintf", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).overload_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "overload_function", + " function" + )))(arg1, zFuncName, nArg) +} + +pub unsafe fn sqlite3_prepare_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).clear_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "clear_bindings", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_module_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module_v2", + " function" + )))(arg1, arg2, arg3, arg4, xDestroy) +} + +pub unsafe fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_open( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_open", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) +} + +pub unsafe fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_read.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_read", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_write.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_write", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_file_control( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).file_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "file_control", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_highwater.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_highwater", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_used", + " function" + )))() +} + +pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_alloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_alloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_enter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_enter", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_leave.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_leave", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_try.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_try", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_open_v2( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open_v2", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_nomem.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_nomem", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_toobig.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_toobig", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sleep.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sleep", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_find.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_find", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_register.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_register", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_unregister.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_unregister", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xthreadsafe.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xthreadsafe", + " function" + )))() +} + +pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_code.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_code", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_test_control( + arg1: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).test_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "test_control", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).randomness.expect(stringify!( + "sqlite3_api contains null pointer for ", + "randomness", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).context_db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "context_db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_result_codes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_result_codes", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_limit( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "limit", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).next_stmt.expect(stringify!( + "sqlite3_api contains null pointer for ", + "next_stmt", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_status( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub const SQLITE_DETERMINISTIC: i32 = 2048; diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8.rs index 3cd6b15d6..ca1961e96 100644 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8.rs +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8.rs @@ -1,7 +1,7 @@ /* automatically generated by rust-bindgen */ pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 6usize] = b"3.6.8\x00"; +pub const SQLITE_VERSION: &'static [u8; 6usize] = b"3.6.8\0"; pub const SQLITE_VERSION_NUMBER: i32 = 3006008; pub const SQLITE_OK: i32 = 0; pub const SQLITE_ERROR: i32 = 1; @@ -196,7 +196,7 @@ pub const SQLITE_STMTSTATUS_SORT: i32 = 2; pub type va_list = __builtin_va_list; pub type __gnuc_va_list = __builtin_va_list; extern "C" { - #[link_name = "sqlite3_version"] + #[link_name = "\u{1}sqlite3_version"] pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; } extern "C" { @@ -210,7 +210,9 @@ extern "C" { } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3([u8; 0]); +pub struct sqlite3 { + _unused: [u8; 0], +} pub type sqlite_int64 = ::std::os::raw::c_longlong; pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; pub type sqlite3_int64 = sqlite_int64; @@ -218,133 +220,283 @@ pub type sqlite3_uint64 = sqlite_uint64; extern "C" { pub fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int; } -pub type sqlite3_callback = - ::std::option::Option ::std::os::raw::c_int>; -extern "C" { - pub fn sqlite3_exec(arg1: *mut sqlite3, - sql: *const ::std::os::raw::c_char, - callback: - ::std::option::Option - ::std::os::raw::c_int>, - arg2: *mut ::std::os::raw::c_void, - errmsg: *mut *mut ::std::os::raw::c_char) - -> ::std::os::raw::c_int; +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +extern "C" { + pub fn sqlite3_exec( + arg1: *mut sqlite3, + sql: *const ::std::os::raw::c_char, + callback: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg2: *mut ::std::os::raw::c_void, + errmsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_file { - pub pMethods: *const sqlite3_file_sqlite3_io_methods, -} -#[repr(C)] -#[derive(Debug, Copy)] -pub struct sqlite3_file_sqlite3_io_methods { - pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option ::std::os::raw::c_int>, - pub xRead: ::std::option::Option ::std::os::raw::c_int>, - pub xWrite: ::std::option::Option ::std::os::raw::c_int>, - pub xTruncate: ::std::option::Option ::std::os::raw::c_int>, - pub xSync: ::std::option::Option ::std::os::raw::c_int>, - pub xFileSize: ::std::option::Option ::std::os::raw::c_int>, - pub xLock: ::std::option::Option ::std::os::raw::c_int>, - pub xUnlock: ::std::option::Option ::std::os::raw::c_int>, - pub xCheckReservedLock: ::std::option::Option - ::std::os::raw::c_int>, - pub xFileControl: ::std::option::Option ::std::os::raw::c_int>, - pub xSectorSize: ::std::option::Option ::std::os::raw::c_int>, - pub xDeviceCharacteristics: ::std::option::Option - ::std::os::raw::c_int>, + pub pMethods: *const sqlite3_io_methods, } #[test] -fn bindgen_test_layout_sqlite3_file_sqlite3_io_methods() { - assert_eq!(::std::mem::size_of::() , - 104usize); - assert_eq!(::std::mem::align_of::() , - 8usize); +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); } -impl Clone for sqlite3_file_sqlite3_io_methods { - fn clone(&self) -> Self { *self } +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, } #[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!(::std::mem::size_of::() , 8usize); - assert_eq!(::std::mem::align_of::() , 8usize); +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); } -impl Clone for sqlite3_file { - fn clone(&self) -> Self { *self } -} -pub type sqlite3_io_methods = sqlite3_file_sqlite3_io_methods; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex([u8; 0]); +pub struct sqlite3_mutex { + _unused: [u8; 0], +} #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_vfs { pub iVersion: ::std::os::raw::c_int, pub szOsFile: ::std::os::raw::c_int, @@ -352,97 +504,283 @@ pub struct sqlite3_vfs { pub pNext: *mut sqlite3_vfs, pub zName: *const ::std::os::raw::c_char, pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option ::std::os::raw::c_int>, - pub xDelete: ::std::option::Option ::std::os::raw::c_int>, - pub xAccess: ::std::option::Option ::std::os::raw::c_int>, - pub xFullPathname: ::std::option::Option ::std::os::raw::c_int>, - pub xDlOpen: ::std::option::Option *mut ::std::os::raw::c_void>, - pub xDlError: ::std::option::Option, - pub xDlSym: ::std::option::Option - ::std::option::Option>, - pub xDlClose: ::std::option::Option, - pub xRandomness: ::std::option::Option ::std::os::raw::c_int>, - pub xSleep: ::std::option::Option ::std::os::raw::c_int>, - pub xCurrentTime: ::std::option::Option ::std::os::raw::c_int>, - pub xGetLastError: ::std::option::Option ::std::os::raw::c_int>, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, } #[test] fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!(::std::mem::size_of::() , 136usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_vfs { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 136usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); } extern "C" { pub fn sqlite3_initialize() -> ::std::os::raw::c_int; @@ -457,52 +795,138 @@ extern "C" { pub fn sqlite3_os_end() -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) - -> ::std::os::raw::c_int; + pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_db_config(arg1: *mut sqlite3, - op: ::std::os::raw::c_int, ...) - -> ::std::os::raw::c_int; + pub fn sqlite3_db_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option *mut ::std::os::raw::c_void>, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option *mut ::std::os::raw::c_void>, - pub xSize: ::std::option::Option ::std::os::raw::c_int>, - pub xRoundup: ::std::option::Option ::std::os::raw::c_int>, - pub xInit: ::std::option::Option ::std::os::raw::c_int>, - pub xShutdown: ::std::option::Option, + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, pub pAppData: *mut ::std::os::raw::c_void, } #[test] fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!(::std::mem::size_of::() , 64usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_mem_methods { - fn clone(&self) -> Self { *self } -} -extern "C" { - pub fn sqlite3_extended_result_codes(arg1: *mut sqlite3, - onoff: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +extern "C" { + pub fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + onoff: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite3_int64; @@ -517,64 +941,68 @@ extern "C" { pub fn sqlite3_interrupt(arg1: *mut sqlite3); } extern "C" { - pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_busy_handler(arg1: *mut sqlite3, - arg2: - ::std::option::Option - ::std::os::raw::c_int>, - arg3: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_busy_timeout(arg1: *mut sqlite3, ms: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_get_table(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - pazResult: *mut *mut *mut ::std::os::raw::c_char, - pnRow: *mut ::std::os::raw::c_int, - pnColumn: *mut ::std::os::raw::c_int, - pzErrmsg: *mut *mut ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_get_table( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + pazResult: *mut *mut *mut ::std::os::raw::c_char, + pnRow: *mut ::std::os::raw::c_int, + pnColumn: *mut ::std::os::raw::c_int, + pzErrmsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char); } extern "C" { pub fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char, ...) - -> *mut ::std::os::raw::c_char; + -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_vmprintf(arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag) - -> *mut ::std::os::raw::c_char; + pub fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_snprintf(arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, ...) - -> *mut ::std::os::raw::c_char; + pub fn sqlite3_snprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_realloc(arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; } extern "C" { pub fn sqlite3_free(arg1: *mut ::std::os::raw::c_void); @@ -583,406 +1011,433 @@ extern "C" { pub fn sqlite3_memory_used() -> sqlite3_int64; } extern "C" { - pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) - -> sqlite3_int64; + pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) -> sqlite3_int64; } extern "C" { - pub fn sqlite3_randomness(N: ::std::os::raw::c_int, - P: *mut ::std::os::raw::c_void); + pub fn sqlite3_randomness(N: ::std::os::raw::c_int, P: *mut ::std::os::raw::c_void); } extern "C" { - pub fn sqlite3_set_authorizer(arg1: *mut sqlite3, - xAuth: - ::std::option::Option - ::std::os::raw::c_int>, - pUserData: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + xAuth: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pUserData: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_trace(arg1: *mut sqlite3, - xTrace: - ::std::option::Option, - arg2: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_profile(arg1: *mut sqlite3, - xProfile: - ::std::option::Option, - arg2: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_profile( + arg1: *mut sqlite3, + xProfile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_progress_handler(arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: - ::std::option::Option - ::std::os::raw::c_int>, - arg4: *mut ::std::os::raw::c_void); + pub fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ); } extern "C" { - pub fn sqlite3_open(filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3) -> ::std::os::raw::c_int; + pub fn sqlite3_open( + filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_open16(filename: *const ::std::os::raw::c_void, - ppDb: *mut *mut sqlite3) -> ::std::os::raw::c_int; + pub fn sqlite3_open16( + filename: *const ::std::os::raw::c_void, + ppDb: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_open_v2(filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3, - flags: ::std::os::raw::c_int, - zVfs: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_open_v2( + filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3, + flags: ::std::os::raw::c_int, + zVfs: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_extended_errcode(db: *mut sqlite3) - -> ::std::os::raw::c_int; + pub fn sqlite3_extended_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_errmsg(arg1: *mut sqlite3) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_errmsg16(arg1: *mut sqlite3) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt([u8; 0]); +pub struct sqlite3_stmt { + _unused: [u8; 0], +} extern "C" { - pub fn sqlite3_limit(arg1: *mut sqlite3, id: ::std::os::raw::c_int, - newVal: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_limit( + arg1: *mut sqlite3, + id: ::std::os::raw::c_int, + newVal: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_prepare( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare_v2(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_prepare_v2( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare16(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_prepare16( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare16_v2(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_prepare16_v2( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct Mem([u8; 0]); +pub struct Mem { + _unused: [u8; 0], +} pub type sqlite3_value = Mem; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_context([u8; 0]); +pub struct sqlite3_context { + _unused: [u8; 0], +} extern "C" { - pub fn sqlite3_bind_blob(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: - ::std::option::Option) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_double(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, arg3: f64) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_int(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_int64(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_int64) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_int64, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_null(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_text(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: - ::std::option::Option) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_text16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: - ::std::option::Option) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_value(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_zeroblob(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - n: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_parameter_name(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_bind_parameter_index(arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_name(arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_name16(arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_database_name(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_database_name16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_table_name(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_table_name16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_origin_name(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_origin_name16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_decltype(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_decltype16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { pub fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_blob(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_bytes(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_bytes16(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) -> f64; + pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64; } extern "C" { - pub fn sqlite3_column_int(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_int64(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) -> sqlite3_int64; + pub fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> sqlite3_int64; } extern "C" { - pub fn sqlite3_column_text(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_uchar; + pub fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar; } extern "C" { - pub fn sqlite3_column_text16(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_type(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_value(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> *mut sqlite3_value; + pub fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value; } extern "C" { - pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_create_function(db: *mut sqlite3, - zFunctionName: - *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: - ::std::option::Option, - xStep: - ::std::option::Option, - xFinal: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function16(db: *mut sqlite3, - zFunctionName: - *const ::std::os::raw::c_void, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: - ::std::option::Option, - xStep: - ::std::option::Option, - xFinal: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) - -> ::std::os::raw::c_int; + pub fn sqlite3_create_function( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function16( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_void, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_transfer_bindings(arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_global_recover() -> ::std::os::raw::c_int; @@ -991,111 +1446,106 @@ extern "C" { pub fn sqlite3_thread_cleanup(); } extern "C" { - pub fn sqlite3_memory_alarm(arg1: - ::std::option::Option, - arg2: *mut ::std::os::raw::c_void, - arg3: sqlite3_int64) -> ::std::os::raw::c_int; + pub fn sqlite3_memory_alarm( + arg1: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_int64, + arg3: ::std::os::raw::c_int, + ), + >, + arg2: *mut ::std::os::raw::c_void, + arg3: sqlite3_int64, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64; } extern "C" { - pub fn sqlite3_value_int(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite3_int64; } extern "C" { - pub fn sqlite3_value_text(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_uchar; + pub fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar; } extern "C" { - pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_type(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_aggregate_context(arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_user_data(arg1: *mut sqlite3_context) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) - -> *mut sqlite3; + pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3; } extern "C" { - pub fn sqlite3_get_auxdata(arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_set_auxdata(arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - arg3: - ::std::option::Option); + pub fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option, + ); } pub type sqlite3_destructor_type = - ::std::option::Option; + ::std::option::Option; extern "C" { - pub fn sqlite3_result_blob(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); + pub fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); } extern "C" { pub fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64); } extern "C" { - pub fn sqlite3_result_error(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int); + pub fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ); } extern "C" { - pub fn sqlite3_result_error16(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int); + pub fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ); } extern "C" { pub fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context); @@ -1104,280 +1554,570 @@ extern "C" { pub fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context); } extern "C" { - pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int); + pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_result_int(arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int); + pub fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, - arg2: sqlite3_int64); + pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite3_int64); } extern "C" { pub fn sqlite3_result_null(arg1: *mut sqlite3_context); } extern "C" { - pub fn sqlite3_result_text(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); -} -extern "C" { - pub fn sqlite3_result_text16(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); -} -extern "C" { - pub fn sqlite3_result_text16le(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); -} -extern "C" { - pub fn sqlite3_result_text16be(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); -} -extern "C" { - pub fn sqlite3_result_value(arg1: *mut sqlite3_context, - arg2: *mut sqlite3_value); -} -extern "C" { - pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, - n: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_create_collation(arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - xCompare: - ::std::option::Option - ::std::os::raw::c_int>) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation_v2(arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - xCompare: - ::std::option::Option - ::std::os::raw::c_int>, - xDestroy: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation16(arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_void, - eTextRep: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - xCompare: - ::std::option::Option - ::std::os::raw::c_int>) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed(arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed16(arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_key(db: *mut sqlite3, pKey: *const ::std::os::raw::c_void, - nKey: ::std::os::raw::c_int) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_rekey(db: *mut sqlite3, - pKey: *const ::std::os::raw::c_void, - nKey: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; -} -extern "C" { - #[link_name = "sqlite3_temp_directory"] + pub fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value); +} +extern "C" { + pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, n: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_create_collation( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation16( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_void, + eTextRep: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_key( + db: *mut sqlite3, + pKey: *const ::std::os::raw::c_void, + nKey: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_rekey( + db: *mut sqlite3, + pKey: *const ::std::os::raw::c_void, + nKey: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "\u{1}sqlite3_temp_directory"] pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) - -> ::std::os::raw::c_int; + pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3; } extern "C" { - pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) - -> *mut sqlite3_stmt; + pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) -> *mut sqlite3_stmt; } extern "C" { - pub fn sqlite3_commit_hook(arg1: *mut sqlite3, - arg2: - ::std::option::Option - ::std::os::raw::c_int>, - arg3: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_rollback_hook(arg1: *mut sqlite3, - arg2: - ::std::option::Option, - arg3: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_update_hook(arg1: *mut sqlite3, - arg2: - ::std::option::Option, - arg3: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_table_column_metadata(db: *mut sqlite3, - zDbName: - *const ::std::os::raw::c_char, - zTableName: - *const ::std::os::raw::c_char, - zColumnName: - *const ::std::os::raw::c_char, - pzDataType: - *mut *const ::std::os::raw::c_char, - pzCollSeq: - *mut *const ::std::os::raw::c_char, - pNotNull: *mut ::std::os::raw::c_int, - pPrimaryKey: - *mut ::std::os::raw::c_int, - pAutoinc: *mut ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_table_column_metadata( + db: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + zTableName: *const ::std::os::raw::c_char, + zColumnName: *const ::std::os::raw::c_char, + pzDataType: *mut *const ::std::os::raw::c_char, + pzCollSeq: *mut *const ::std::os::raw::c_char, + pNotNull: *mut ::std::os::raw::c_int, + pPrimaryKey: *mut ::std::os::raw::c_int, + pAutoinc: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_load_extension(db: *mut sqlite3, - zFile: *const ::std::os::raw::c_char, - zProc: *const ::std::os::raw::c_char, - pzErrMsg: *mut *mut ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_load_extension( + db: *mut sqlite3, + zFile: *const ::std::os::raw::c_char, + zProc: *const ::std::os::raw::c_char, + pzErrMsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_enable_load_extension(db: *mut sqlite3, - onoff: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_enable_load_extension( + db: *mut sqlite3, + onoff: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_auto_extension(xEntryPoint: - ::std::option::Option) - -> ::std::os::raw::c_int; + pub fn sqlite3_auto_extension( + xEntryPoint: ::std::option::Option, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_reset_auto_extension(); } #[repr(C)] -#[derive(Debug, Copy)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, } #[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!(::std::mem::size_of::() , 24usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_vtab { - fn clone(&self) -> Self { *self } +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 160usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_index_info { pub nConstraint: ::std::os::raw::c_int, pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, @@ -1391,7 +2131,7 @@ pub struct sqlite3_index_info { pub estimatedCost: f64, } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_index_info_sqlite3_index_constraint { pub iColumn: ::std::os::raw::c_int, pub op: ::std::os::raw::c_uchar, @@ -1400,275 +2140,458 @@ pub struct sqlite3_index_info_sqlite3_index_constraint { } #[test] fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!(::std::mem::size_of::() - , 12usize); - assert_eq!(::std::mem::align_of::() - , 4usize); -} -impl Clone for sqlite3_index_info_sqlite3_index_constraint { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_index_info_sqlite3_index_orderby { pub iColumn: ::std::os::raw::c_int, pub desc: ::std::os::raw::c_uchar, } #[test] fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!(::std::mem::size_of::() - , 8usize); - assert_eq!(::std::mem::align_of::() - , 4usize); -} -impl Clone for sqlite3_index_info_sqlite3_index_orderby { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_index_info_sqlite3_index_constraint_usage { pub argvIndex: ::std::os::raw::c_int, pub omit: ::std::os::raw::c_uchar, } #[test] fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!(::std::mem::size_of::() - , 8usize); - assert_eq!(::std::mem::align_of::() - , 4usize); -} -impl Clone for sqlite3_index_info_sqlite3_index_constraint_usage { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); } #[test] fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!(::std::mem::size_of::() , 72usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_index_info { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); +} +extern "C" { + pub fn sqlite3_create_module( + db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + arg1: *const sqlite3_module, + arg2: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_module_v2( + db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + arg1: *const sqlite3_module, + arg2: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy)] -pub struct sqlite3_vtab_cursor { - pub pVtab: *mut sqlite3_vtab, +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, } #[test] -fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!(::std::mem::size_of::() , 8usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_vtab_cursor { - fn clone(&self) -> Self { *self } +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option ::std::os::raw::c_int>, - pub xConnect: ::std::option::Option ::std::os::raw::c_int>, - pub xBestIndex: ::std::option::Option ::std::os::raw::c_int>, - pub xDisconnect: ::std::option::Option ::std::os::raw::c_int>, - pub xDestroy: ::std::option::Option ::std::os::raw::c_int>, - pub xOpen: ::std::option::Option ::std::os::raw::c_int>, - pub xClose: ::std::option::Option ::std::os::raw::c_int>, - pub xFilter: ::std::option::Option ::std::os::raw::c_int>, - pub xNext: ::std::option::Option ::std::os::raw::c_int>, - pub xEof: ::std::option::Option ::std::os::raw::c_int>, - pub xColumn: ::std::option::Option ::std::os::raw::c_int>, - pub xRowid: ::std::option::Option ::std::os::raw::c_int>, - pub xUpdate: ::std::option::Option ::std::os::raw::c_int>, - pub xBegin: ::std::option::Option ::std::os::raw::c_int>, - pub xSync: ::std::option::Option ::std::os::raw::c_int>, - pub xCommit: ::std::option::Option ::std::os::raw::c_int>, - pub xRollback: ::std::option::Option ::std::os::raw::c_int>, - pub xFindFunction: ::std::option::Option, - ppArg: - *mut *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int>, - pub xRename: ::std::option::Option ::std::os::raw::c_int>, +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, } #[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!(::std::mem::size_of::() , 160usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_module { - fn clone(&self) -> Self { *self } -} -extern "C" { - pub fn sqlite3_create_module(db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - arg1: *const sqlite3_module, - arg2: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_module_v2(db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - arg1: *const sqlite3_module, - arg2: *mut ::std::os::raw::c_void, - xDestroy: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_declare_vtab(arg1: *mut sqlite3, - zCreateTable: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_overload_function(arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +extern "C" { + pub fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + zCreateTable: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob([u8; 0]); +pub struct sqlite3_blob { + _unused: [u8; 0], +} extern "C" { - pub fn sqlite3_blob_open(arg1: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - zTable: *const ::std::os::raw::c_char, - zColumn: *const ::std::os::raw::c_char, - iRow: sqlite3_int64, - flags: ::std::os::raw::c_int, - ppBlob: *mut *mut sqlite3_blob) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_open( + arg1: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + zTable: *const ::std::os::raw::c_char, + zColumn: *const ::std::os::raw::c_char, + iRow: sqlite3_int64, + flags: ::std::os::raw::c_int, + ppBlob: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_read(arg1: *mut sqlite3_blob, - Z: *mut ::std::os::raw::c_void, - N: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + Z: *mut ::std::os::raw::c_void, + N: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_write(arg1: *mut sqlite3_blob, - z: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + z: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) - -> *mut sqlite3_vfs; + pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs; } extern "C" { - pub fn sqlite3_vfs_register(arg1: *mut sqlite3_vfs, - makeDflt: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + makeDflt: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) - -> ::std::os::raw::c_int; + pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) - -> *mut sqlite3_mutex; + pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex; } extern "C" { pub fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex); @@ -1677,159 +2600,436 @@ extern "C" { pub fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex); } extern "C" { - pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) - -> ::std::os::raw::c_int; + pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option *mut sqlite3_mutex>, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexNotheld: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, } #[test] fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!(::std::mem::size_of::() , 72usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_mutex_methods { - fn clone(&self) -> Self { *self } -} -extern "C" { - pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) - -> ::std::os::raw::c_int; + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +extern "C" { + pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex; } extern "C" { - pub fn sqlite3_file_control(arg1: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - op: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_file_control( + arg1: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + op: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) - -> ::std::os::raw::c_int; + pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_status(op: ::std::os::raw::c_int, - pCurrent: *mut ::std::os::raw::c_int, - pHighwater: *mut ::std::os::raw::c_int, - resetFlag: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_status( + op: ::std::os::raw::c_int, + pCurrent: *mut ::std::os::raw::c_int, + pHighwater: *mut ::std::os::raw::c_int, + resetFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_db_status(arg1: *mut sqlite3, op: ::std::os::raw::c_int, - pCur: *mut ::std::os::raw::c_int, - pHiwtr: *mut ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_db_status( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + pCur: *mut ::std::os::raw::c_int, + pHiwtr: *mut ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_stmt_status(arg1: *mut sqlite3_stmt, - op: ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_stmt_status( + arg1: *mut sqlite3_stmt, + op: ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache([u8; 0]); +pub struct sqlite3_pcache { + _unused: [u8; 0], +} #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_pcache_methods { pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option ::std::os::raw::c_int>, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option *mut sqlite3_pcache>, - pub xCachesize: ::std::option::Option, - pub xPagecount: ::std::option::Option ::std::os::raw::c_int>, - pub xFetch: ::std::option::Option *mut ::std::os::raw::c_void>, - pub xUnpin: ::std::option::Option, - pub xRekey: ::std::option::Option, - pub xTruncate: ::std::option::Option, - pub xDestroy: ::std::option::Option, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, } #[test] fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!(::std::mem::size_of::() , 88usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_pcache_methods { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); } +pub type __builtin_va_list = [__va_list_tag; 1usize]; #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct __va_list_tag { pub gp_offset: ::std::os::raw::c_uint, pub fp_offset: ::std::os::raw::c_uint, pub overflow_arg_area: *mut ::std::os::raw::c_void, pub reg_save_area: *mut ::std::os::raw::c_void, } -impl Clone for __va_list_tag { - fn clone(&self) -> Self { *self } +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); } -pub type __builtin_va_list = [__va_list_tag; 1usize]; - pub const SQLITE_DETERMINISTIC: i32 = 2048; diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext-embed.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext-embed.rs new file mode 100644 index 000000000..d589062e5 --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext-embed.rs @@ -0,0 +1,8584 @@ +/* automatically generated by rust-bindgen */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.7.16\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3007016; +pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = + b"2013-03-18 11:39:23 66d5f2b76750f3520eb7a495f6247206758f5b90\0"; +pub const SQLITE_OK: i32 = 0; +pub const SQLITE_ERROR: i32 = 1; +pub const SQLITE_INTERNAL: i32 = 2; +pub const SQLITE_PERM: i32 = 3; +pub const SQLITE_ABORT: i32 = 4; +pub const SQLITE_BUSY: i32 = 5; +pub const SQLITE_LOCKED: i32 = 6; +pub const SQLITE_NOMEM: i32 = 7; +pub const SQLITE_READONLY: i32 = 8; +pub const SQLITE_INTERRUPT: i32 = 9; +pub const SQLITE_IOERR: i32 = 10; +pub const SQLITE_CORRUPT: i32 = 11; +pub const SQLITE_NOTFOUND: i32 = 12; +pub const SQLITE_FULL: i32 = 13; +pub const SQLITE_CANTOPEN: i32 = 14; +pub const SQLITE_PROTOCOL: i32 = 15; +pub const SQLITE_EMPTY: i32 = 16; +pub const SQLITE_SCHEMA: i32 = 17; +pub const SQLITE_TOOBIG: i32 = 18; +pub const SQLITE_CONSTRAINT: i32 = 19; +pub const SQLITE_MISMATCH: i32 = 20; +pub const SQLITE_MISUSE: i32 = 21; +pub const SQLITE_NOLFS: i32 = 22; +pub const SQLITE_AUTH: i32 = 23; +pub const SQLITE_FORMAT: i32 = 24; +pub const SQLITE_RANGE: i32 = 25; +pub const SQLITE_NOTADB: i32 = 26; +pub const SQLITE_ROW: i32 = 100; +pub const SQLITE_DONE: i32 = 101; +pub const SQLITE_IOERR_READ: i32 = 266; +pub const SQLITE_IOERR_SHORT_READ: i32 = 522; +pub const SQLITE_IOERR_WRITE: i32 = 778; +pub const SQLITE_IOERR_FSYNC: i32 = 1034; +pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; +pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; +pub const SQLITE_IOERR_FSTAT: i32 = 1802; +pub const SQLITE_IOERR_UNLOCK: i32 = 2058; +pub const SQLITE_IOERR_RDLOCK: i32 = 2314; +pub const SQLITE_IOERR_DELETE: i32 = 2570; +pub const SQLITE_IOERR_BLOCKED: i32 = 2826; +pub const SQLITE_IOERR_NOMEM: i32 = 3082; +pub const SQLITE_IOERR_ACCESS: i32 = 3338; +pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; +pub const SQLITE_IOERR_LOCK: i32 = 3850; +pub const SQLITE_IOERR_CLOSE: i32 = 4106; +pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; +pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; +pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; +pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; +pub const SQLITE_IOERR_SHMMAP: i32 = 5386; +pub const SQLITE_IOERR_SEEK: i32 = 5642; +pub const SQLITE_IOERR_DELETE_NOENT: i32 = 5898; +pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; +pub const SQLITE_BUSY_RECOVERY: i32 = 261; +pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; +pub const SQLITE_CANTOPEN_ISDIR: i32 = 526; +pub const SQLITE_CANTOPEN_FULLPATH: i32 = 782; +pub const SQLITE_CORRUPT_VTAB: i32 = 267; +pub const SQLITE_READONLY_RECOVERY: i32 = 264; +pub const SQLITE_READONLY_CANTLOCK: i32 = 520; +pub const SQLITE_READONLY_ROLLBACK: i32 = 776; +pub const SQLITE_ABORT_ROLLBACK: i32 = 516; +pub const SQLITE_CONSTRAINT_CHECK: i32 = 275; +pub const SQLITE_CONSTRAINT_COMMITHOOK: i32 = 531; +pub const SQLITE_CONSTRAINT_FOREIGNKEY: i32 = 787; +pub const SQLITE_CONSTRAINT_FUNCTION: i32 = 1043; +pub const SQLITE_CONSTRAINT_NOTNULL: i32 = 1299; +pub const SQLITE_CONSTRAINT_PRIMARYKEY: i32 = 1555; +pub const SQLITE_CONSTRAINT_TRIGGER: i32 = 1811; +pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067; +pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323; +pub const SQLITE_OPEN_READONLY: i32 = 1; +pub const SQLITE_OPEN_READWRITE: i32 = 2; +pub const SQLITE_OPEN_CREATE: i32 = 4; +pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; +pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; +pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; +pub const SQLITE_OPEN_URI: i32 = 64; +pub const SQLITE_OPEN_MEMORY: i32 = 128; +pub const SQLITE_OPEN_MAIN_DB: i32 = 256; +pub const SQLITE_OPEN_TEMP_DB: i32 = 512; +pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; +pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; +pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; +pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; +pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; +pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; +pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; +pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; +pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; +pub const SQLITE_OPEN_WAL: i32 = 524288; +pub const SQLITE_IOCAP_ATOMIC: i32 = 1; +pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; +pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; +pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; +pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; +pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; +pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; +pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; +pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; +pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; +pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; +pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; +pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE: i32 = 4096; +pub const SQLITE_LOCK_NONE: i32 = 0; +pub const SQLITE_LOCK_SHARED: i32 = 1; +pub const SQLITE_LOCK_RESERVED: i32 = 2; +pub const SQLITE_LOCK_PENDING: i32 = 3; +pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; +pub const SQLITE_SYNC_NORMAL: i32 = 2; +pub const SQLITE_SYNC_FULL: i32 = 3; +pub const SQLITE_SYNC_DATAONLY: i32 = 16; +pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; +pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_LAST_ERRNO: i32 = 4; +pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; +pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; +pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; +pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; +pub const SQLITE_FCNTL_WIN32_AV_RETRY: i32 = 9; +pub const SQLITE_FCNTL_PERSIST_WAL: i32 = 10; +pub const SQLITE_FCNTL_OVERWRITE: i32 = 11; +pub const SQLITE_FCNTL_VFSNAME: i32 = 12; +pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE: i32 = 13; +pub const SQLITE_FCNTL_PRAGMA: i32 = 14; +pub const SQLITE_FCNTL_BUSYHANDLER: i32 = 15; +pub const SQLITE_FCNTL_TEMPFILENAME: i32 = 16; +pub const SQLITE_ACCESS_EXISTS: i32 = 0; +pub const SQLITE_ACCESS_READWRITE: i32 = 1; +pub const SQLITE_ACCESS_READ: i32 = 2; +pub const SQLITE_SHM_UNLOCK: i32 = 1; +pub const SQLITE_SHM_LOCK: i32 = 2; +pub const SQLITE_SHM_SHARED: i32 = 4; +pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; +pub const SQLITE_SHM_NLOCK: i32 = 8; +pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; +pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; +pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; +pub const SQLITE_CONFIG_MALLOC: i32 = 4; +pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; +pub const SQLITE_CONFIG_SCRATCH: i32 = 6; +pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; +pub const SQLITE_CONFIG_HEAP: i32 = 8; +pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; +pub const SQLITE_CONFIG_MUTEX: i32 = 10; +pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; +pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; +pub const SQLITE_CONFIG_PCACHE: i32 = 14; +pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; +pub const SQLITE_CONFIG_LOG: i32 = 16; +pub const SQLITE_CONFIG_URI: i32 = 17; +pub const SQLITE_CONFIG_PCACHE2: i32 = 18; +pub const SQLITE_CONFIG_GETPCACHE2: i32 = 19; +pub const SQLITE_CONFIG_COVERING_INDEX_SCAN: i32 = 20; +pub const SQLITE_CONFIG_SQLLOG: i32 = 21; +pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; +pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; +pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; +pub const SQLITE_DENY: i32 = 1; +pub const SQLITE_IGNORE: i32 = 2; +pub const SQLITE_CREATE_INDEX: i32 = 1; +pub const SQLITE_CREATE_TABLE: i32 = 2; +pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; +pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; +pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; +pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; +pub const SQLITE_CREATE_TRIGGER: i32 = 7; +pub const SQLITE_CREATE_VIEW: i32 = 8; +pub const SQLITE_DELETE: i32 = 9; +pub const SQLITE_DROP_INDEX: i32 = 10; +pub const SQLITE_DROP_TABLE: i32 = 11; +pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; +pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; +pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; +pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; +pub const SQLITE_DROP_TRIGGER: i32 = 16; +pub const SQLITE_DROP_VIEW: i32 = 17; +pub const SQLITE_INSERT: i32 = 18; +pub const SQLITE_PRAGMA: i32 = 19; +pub const SQLITE_READ: i32 = 20; +pub const SQLITE_SELECT: i32 = 21; +pub const SQLITE_TRANSACTION: i32 = 22; +pub const SQLITE_UPDATE: i32 = 23; +pub const SQLITE_ATTACH: i32 = 24; +pub const SQLITE_DETACH: i32 = 25; +pub const SQLITE_ALTER_TABLE: i32 = 26; +pub const SQLITE_REINDEX: i32 = 27; +pub const SQLITE_ANALYZE: i32 = 28; +pub const SQLITE_CREATE_VTABLE: i32 = 29; +pub const SQLITE_DROP_VTABLE: i32 = 30; +pub const SQLITE_FUNCTION: i32 = 31; +pub const SQLITE_SAVEPOINT: i32 = 32; +pub const SQLITE_COPY: i32 = 0; +pub const SQLITE_LIMIT_LENGTH: i32 = 0; +pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; +pub const SQLITE_LIMIT_COLUMN: i32 = 2; +pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; +pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; +pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; +pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; +pub const SQLITE_LIMIT_ATTACHED: i32 = 7; +pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; +pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; +pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; +pub const SQLITE_INTEGER: i32 = 1; +pub const SQLITE_FLOAT: i32 = 2; +pub const SQLITE_BLOB: i32 = 4; +pub const SQLITE_NULL: i32 = 5; +pub const SQLITE_TEXT: i32 = 3; +pub const SQLITE3_TEXT: i32 = 3; +pub const SQLITE_UTF8: i32 = 1; +pub const SQLITE_UTF16LE: i32 = 2; +pub const SQLITE_UTF16BE: i32 = 3; +pub const SQLITE_UTF16: i32 = 4; +pub const SQLITE_ANY: i32 = 5; +pub const SQLITE_UTF16_ALIGNED: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; +pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; +pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; +pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; +pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; +pub const SQLITE_MUTEX_FAST: i32 = 0; +pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; +pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; +pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; +pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; +pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; +pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; +pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; +pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; +pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; +pub const SQLITE_TESTCTRL_FIRST: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; +pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; +pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; +pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; +pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; +pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; +pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; +pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; +pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; +pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; +pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; +pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 17; +pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 18; +pub const SQLITE_TESTCTRL_EXPLAIN_STMT: i32 = 19; +pub const SQLITE_TESTCTRL_LAST: i32 = 19; +pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; +pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; +pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; +pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; +pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; +pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; +pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; +pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; +pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; +pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; +pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; +pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; +pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; +pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; +pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; +pub const SQLITE_DBSTATUS_CACHE_HIT: i32 = 7; +pub const SQLITE_DBSTATUS_CACHE_MISS: i32 = 8; +pub const SQLITE_DBSTATUS_CACHE_WRITE: i32 = 9; +pub const SQLITE_DBSTATUS_MAX: i32 = 9; +pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; +pub const SQLITE_STMTSTATUS_SORT: i32 = 2; +pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; +pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; +pub const SQLITE_CHECKPOINT_FULL: i32 = 1; +pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; +pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; +pub const SQLITE_ROLLBACK: i32 = 1; +pub const SQLITE_FAIL: i32 = 3; +pub const SQLITE_REPLACE: i32 = 5; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; +extern "C" { + #[link_name = "\u{1}sqlite3_version"] + pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3 { + _unused: [u8; 0], +} +pub type sqlite_int64 = ::std::os::raw::c_longlong; +pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; +pub type sqlite3_int64 = sqlite_int64; +pub type sqlite3_uint64 = sqlite_uint64; +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_file { + pub pMethods: *const sqlite3_io_methods, +} +#[test] +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xShmMap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iPg: ::std::os::raw::c_int, + pgsz: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xShmLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + offset: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xShmBarrier: ::std::option::Option, + pub xShmUnmap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + deleteFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 136usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmMap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmBarrier) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmUnmap) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +pub type sqlite3_syscall_ptr = ::std::option::Option; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vfs { + pub iVersion: ::std::os::raw::c_int, + pub szOsFile: ::std::os::raw::c_int, + pub mxPathname: ::std::os::raw::c_int, + pub pNext: *mut sqlite3_vfs, + pub zName: *const ::std::os::raw::c_char, + pub pAppData: *mut ::std::os::raw::c_void, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTimeInt64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xSetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: sqlite3_syscall_ptr, + ) -> ::std::os::raw::c_int, + >, + pub xGetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> sqlite3_syscall_ptr, + >, + pub xNextSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_vfs() { + assert_eq!( + ::std::mem::size_of::(), + 168usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTimeInt64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xNextSystemCall) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mem_methods { + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub pAppData: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_mem_methods() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_stmt { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Mem { + _unused: [u8; 0], +} +pub type sqlite3_value = Mem; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_context { + _unused: [u8; 0], +} +pub type sqlite3_destructor_type = + ::std::option::Option; +extern "C" { + #[link_name = "\u{1}sqlite3_temp_directory"] + pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "\u{1}sqlite3_data_directory"] + pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSavepoint: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRelease: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRollbackTo: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 184usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSavepoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRelease) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollbackTo) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info { + pub nConstraint: ::std::os::raw::c_int, + pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, + pub nOrderBy: ::std::os::raw::c_int, + pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, + pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, + pub idxNum: ::std::os::raw::c_int, + pub idxStr: *mut ::std::os::raw::c_char, + pub needToFreeIdxStr: ::std::os::raw::c_int, + pub orderByConsumed: ::std::os::raw::c_int, + pub estimatedCost: f64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint { + pub iColumn: ::std::os::raw::c_int, + pub op: ::std::os::raw::c_uchar, + pub usable: ::std::os::raw::c_uchar, + pub iTermOffset: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_orderby { + pub iColumn: ::std::os::raw::c_int, + pub desc: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint_usage { + pub argvIndex: ::std::os::raw::c_int, + pub omit: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); +} +#[test] +fn bindgen_test_layout_sqlite3_index_info() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_blob { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex_methods { + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_mutex_methods() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_page { + pub pBuf: *mut ::std::os::raw::c_void, + pub pExtra: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_page() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pBuf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pExtra) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods2 { + pub iVersion: ::std::os::raw::c_int, + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + szExtra: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache_page, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, + pub xShrink: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods2() { + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iVersion as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDestroy as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShrink) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods { + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_backup { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_geometry { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut f64, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_geometry() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(xDelUser) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_api_routines { + pub aggregate_context: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub aggregate_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, + >, + pub bind_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_double: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int, + >, + pub bind_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, + ) -> ::std::os::raw::c_int, + >, + pub bind_null: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub bind_parameter_index: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub bind_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub busy_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub busy_timeout: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub changes: + ::std::option::Option ::std::os::raw::c_int>, + pub close: + ::std::option::Option ::std::os::raw::c_int>, + pub collation_needed: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub collation_needed16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub column_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_bytes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_bytes16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub column_database_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_database_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_decltype: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_decltype16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_double: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, + >, + pub column_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_int64: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, + >, + pub column_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_origin_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_origin_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_table_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_table_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar, + >, + pub column_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_type: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value, + >, + pub commit_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub complete: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub complete16: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub create_collation: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_collation16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_function16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_module: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub data_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub db_handle: + ::std::option::Option *mut sqlite3>, + pub declare_vtab: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub enable_shared_cache: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub errmsg: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, + >, + pub errmsg16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, + >, + pub exec: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub expired: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub finalize: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub free: ::std::option::Option, + pub free_table: + ::std::option::Option, + pub get_autocommit: + ::std::option::Option ::std::os::raw::c_int>, + pub get_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub get_table: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub global_recover: ::std::option::Option ::std::os::raw::c_int>, + pub interruptx: ::std::option::Option, + pub last_insert_rowid: + ::std::option::Option sqlite_int64>, + pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, + pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, + pub malloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub mprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub open16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub prepare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub profile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub progress_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ), + >, + pub realloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub result_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_double: + ::std::option::Option, + pub result_error: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_error16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_int64: + ::std::option::Option, + pub result_null: ::std::option::Option, + pub result_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16be: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16le: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_value: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), + >, + pub rollback_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub set_authorizer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub set_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, + ), + >, + pub snprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub step: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub table_column_metadata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub thread_cleanup: ::std::option::Option, + pub total_changes: + ::std::option::Option ::std::os::raw::c_int>, + pub trace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub transfer_bindings: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int, + >, + pub update_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub user_data: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, + >, + pub value_blob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_bytes16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_double: ::std::option::Option f64>, + pub value_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_int64: + ::std::option::Option sqlite_int64>, + pub value_numeric_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_text: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, + >, + pub value_text16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16be: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16le: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub vmprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub overload_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub prepare_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub clear_bindings: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub create_module_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_close: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int, + >, + pub blob_read: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_write: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub create_collation_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub file_control: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub memory_highwater: + ::std::option::Option sqlite3_int64>, + pub memory_used: ::std::option::Option sqlite3_int64>, + pub mutex_alloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub mutex_enter: ::std::option::Option, + pub mutex_free: ::std::option::Option, + pub mutex_leave: ::std::option::Option, + pub mutex_try: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub open_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub release_memory: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub result_error_nomem: ::std::option::Option, + pub result_error_toobig: + ::std::option::Option, + pub sleep: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub soft_heap_limit: ::std::option::Option, + pub vfs_find: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, + >, + pub vfs_register: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub vfs_unregister: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, + >, + pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, + pub result_zeroblob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_error_code: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub test_control: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, + >, + pub randomness: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), + >, + pub context_db_handle: + ::std::option::Option *mut sqlite3>, + pub extended_result_codes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub limit: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub next_stmt: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, + >, + pub sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, + >, + pub status: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub backup_finish: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_init: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, + ) -> *mut sqlite3_backup, + >, + pub backup_pagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_remaining: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_step: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub compileoption_get: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, + >, + pub compileoption_used: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub create_function_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub db_config: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int, + >, + pub db_mutex: + ::std::option::Option *mut sqlite3_mutex>, + pub db_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub extended_errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub log: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char, ...), + >, + pub soft_heap_limit64: + ::std::option::Option sqlite3_int64>, + pub sourceid: ::std::option::Option *const ::std::os::raw::c_char>, + pub stmt_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub strnicmp: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub unlock_notify: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub wal_autocheckpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub wal_checkpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub wal_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub blob_reopen: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob, arg2: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub vtab_config: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int, + >, + pub vtab_on_conflict: + ::std::option::Option ::std::os::raw::c_int>, + pub close_v2: + ::std::option::Option ::std::os::raw::c_int>, + pub db_filename: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, + pub db_readonly: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub db_release_memory: + ::std::option::Option ::std::os::raw::c_int>, + pub errstr: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, + >, + pub stmt_busy: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub stmt_readonly: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub stricmp: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub uri_boolean: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub uri_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64, + ) -> sqlite3_int64, + >, + pub uri_parameter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, + pub vsnprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub wal_checkpoint_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_api_routines() { + assert_eq!( + ::std::mem::size_of::(), + 1536usize, + concat!("Size of: ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_context as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_context) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_count as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_double as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_count as *const _ + as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_index as *const _ + as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_index) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_name as *const _ + as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text16 as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_handler as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_handler) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_timeout as *const _ as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_timeout) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed as *const _ as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_blob as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes as *const _ as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize + }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_count as *const _ as usize + }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name as *const _ + as usize + }, + 184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name16 as *const _ + as usize + }, + 192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype as *const _ as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize + }, + 208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_double as *const _ as usize + }, + 216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, + 224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_int64 as *const _ as usize + }, + 232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name as *const _ as usize + }, + 240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name16 as *const _ as usize + }, + 248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name as *const _ as usize + }, + 256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name16 as *const _ + as usize + }, + 264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name as *const _ as usize + }, + 272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name16 as *const _ + as usize + }, + 280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text as *const _ as usize + }, + 288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text16 as *const _ as usize + }, + 296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_type as *const _ as usize + }, + 304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_type) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_value as *const _ as usize + }, + 312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).commit_hook as *const _ as usize + }, + 320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(commit_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, + 328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, + 336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation as *const _ as usize + }, + 344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation16 as *const _ as usize + }, + 352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function as *const _ as usize + }, + 360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function16 as *const _ as usize + }, + 368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module as *const _ as usize + }, + 376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, + 384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(data_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, + 392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).declare_vtab as *const _ as usize + }, + 400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(declare_vtab) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).enable_shared_cache as *const _ + as usize + }, + 408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(enable_shared_cache) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, + 416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, + 424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, + 432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, + 440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(exec) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, + 448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(expired) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, + 456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(finalize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, + 464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, + 472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_autocommit as *const _ as usize + }, + 480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_autocommit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_auxdata as *const _ as usize + }, + 488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, + 496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).global_recover as *const _ as usize + }, + 504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(global_recover) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, + 512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(interruptx) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize + }, + 520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(last_insert_rowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, + 528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).libversion_number as *const _ as usize + }, + 536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion_number) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, + 544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, + 552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, + 560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, + 568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, + 576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, + 584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, + 592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(profile) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).progress_handler as *const _ as usize + }, + 600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(progress_handler) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, + 608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, + 616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob as *const _ as usize + }, + 624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_double as *const _ as usize + }, + 632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_double) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error as *const _ as usize + }, + 640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error16 as *const _ as usize + }, + 648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, + 656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_int64 as *const _ as usize + }, + 664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_null as *const _ as usize + }, + 672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text as *const _ as usize + }, + 680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16 as *const _ as usize + }, + 688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16be as *const _ as usize + }, + 696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16le as *const _ as usize + }, + 704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16le) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_value as *const _ as usize + }, + 712usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rollback_hook as *const _ as usize + }, + 720usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(rollback_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_authorizer as *const _ as usize + }, + 728usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_authorizer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_auxdata as *const _ as usize + }, + 736usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).snprintf as *const _ as usize }, + 744usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(snprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, + 752usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).table_column_metadata as *const _ + as usize + }, + 760usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(table_column_metadata) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize + }, + 768usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(thread_cleanup) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).total_changes as *const _ as usize + }, + 776usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(total_changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, + 784usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(trace) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize + }, + 792usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(transfer_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).update_hook as *const _ as usize + }, + 800usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(update_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, + 808usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(user_data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, + 816usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes as *const _ as usize + }, + 824usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize + }, + 832usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_double as *const _ as usize + }, + 840usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, + 848usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_int64 as *const _ as usize + }, + 856usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize + }, + 864usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_numeric_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, + 872usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16 as *const _ as usize + }, + 880usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16be as *const _ as usize + }, + 888usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16le as *const _ as usize + }, + 896usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16le) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, + 904usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, + 912usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vmprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).overload_function as *const _ as usize + }, + 920usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(overload_function) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, + 928usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize + }, + 936usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).clear_bindings as *const _ as usize + }, + 944usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(clear_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize + }, + 952usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize + }, + 960usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, + 968usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_bytes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, + 976usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_close) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, + 984usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, + 992usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_read) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, + 1000usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_write) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation_v2 as *const _ + as usize + }, + 1008usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).file_control as *const _ as usize + }, + 1016usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(file_control) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_highwater as *const _ as usize + }, + 1024usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_highwater) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_used as *const _ as usize + }, + 1032usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize + }, + 1040usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_alloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_enter as *const _ as usize + }, + 1048usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_enter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, + 1056usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_leave as *const _ as usize + }, + 1064usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_leave) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, + 1072usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_try) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, + 1080usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).release_memory as *const _ as usize + }, + 1088usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(release_memory) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize + }, + 1096usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_nomem) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_toobig as *const _ + as usize + }, + 1104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_toobig) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, + 1112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sleep) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize + }, + 1120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, + 1128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_find) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_register as *const _ as usize + }, + 1136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_register) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize + }, + 1144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_unregister) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize + }, + 1152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xthreadsafe) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize + }, + 1160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_code as *const _ as usize + }, + 1168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_code) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).test_control as *const _ as usize + }, + 1176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(test_control) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, + 1184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(randomness) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).context_db_handle as *const _ as usize + }, + 1192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(context_db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_result_codes as *const _ + as usize + }, + 1200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_result_codes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, + 1208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, + 1216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(next_stmt) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, + 1224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sql) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, + 1232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_finish as *const _ as usize + }, + 1240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_finish) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_init as *const _ as usize + }, + 1248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_init) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_pagecount as *const _ as usize + }, + 1256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_pagecount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_remaining as *const _ as usize + }, + 1264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_remaining) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_step as *const _ as usize + }, + 1272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_get as *const _ as usize + }, + 1280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_get) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_used as *const _ as usize + }, + 1288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function_v2 as *const _ as usize + }, + 1296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function_v2) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_config as *const _ as usize }, + 1304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_config) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_mutex as *const _ as usize }, + 1312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_mutex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_status as *const _ as usize }, + 1320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_errcode as *const _ as usize + }, + 1328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).log as *const _ as usize }, + 1336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(log) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit64 as *const _ as usize + }, + 1344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sourceid as *const _ as usize }, + 1352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sourceid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stmt_status as *const _ as usize + }, + 1360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_status) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strnicmp as *const _ as usize }, + 1368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strnicmp) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).unlock_notify as *const _ as usize + }, + 1376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(unlock_notify) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_autocheckpoint as *const _ as usize + }, + 1384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_autocheckpoint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_checkpoint as *const _ as usize + }, + 1392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_checkpoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).wal_hook as *const _ as usize }, + 1400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).blob_reopen as *const _ as usize + }, + 1408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_reopen) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_config as *const _ as usize + }, + 1416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_config) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_on_conflict as *const _ as usize + }, + 1424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_on_conflict) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close_v2 as *const _ as usize }, + 1432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_filename as *const _ as usize + }, + 1440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_filename) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_readonly as *const _ as usize + }, + 1448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_readonly) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_release_memory as *const _ as usize + }, + 1456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_release_memory) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errstr as *const _ as usize }, + 1464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errstr) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).stmt_busy as *const _ as usize }, + 1472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_busy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stmt_readonly as *const _ as usize + }, + 1480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_readonly) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).stricmp as *const _ as usize }, + 1488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stricmp) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).uri_boolean as *const _ as usize + }, + 1496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_boolean) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).uri_int64 as *const _ as usize }, + 1504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).uri_parameter as *const _ as usize + }, + 1512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_parameter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vsnprintf as *const _ as usize }, + 1520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vsnprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_checkpoint_v2 as *const _ as usize + }, + 1528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_checkpoint_v2) + ) + ); +} +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} + +// bindings were built with loadable_extension_embedded: +// define sqlite3_api as an extern since this code will be embedded +// within a loadable extension that defines and exports this itself +extern "C" { + #[no_mangle] + pub static mut sqlite3_api: *mut sqlite3_api_routines; +} + +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) + +pub unsafe fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_context.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_context", + " function" + )))(arg1, nBytes) +} + +pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_double", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_null", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_index.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_index", + " function" + )))(arg1, zName) +} + +pub unsafe fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_value", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_handler", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_timeout.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_timeout", + " function" + )))(arg1, ms) +} + +pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_blob", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype", + " function" + )))(arg1, i) +} + +pub unsafe fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_double", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int64", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_type", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_value", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).commit_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "commit_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete16", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_create_collation( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_collation16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_function( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_function16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function16", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_module( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).data_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "data_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).declare_vtab.expect(stringify!( + "sqlite3_api contains null pointer for ", + "declare_vtab", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).enable_shared_cache.expect(stringify!( + "sqlite3_api contains null pointer for ", + "enable_shared_cache", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errcode", + " function" + )))(db) +} + +pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_exec( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).exec.expect(stringify!( + "sqlite3_api contains null pointer for ", + "exec", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).expired.expect(stringify!( + "sqlite3_api contains null pointer for ", + "expired", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).finalize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "finalize", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free_table", + " function" + )))(result) +} + +pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_autocommit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_autocommit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_auxdata", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_get_table( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_table", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).global_recover.expect(stringify!( + "sqlite3_api contains null pointer for ", + "global_recover", + " function" + )))() +} + +pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).interruptx.expect(stringify!( + "sqlite3_api contains null pointer for ", + "interruptx", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).last_insert_rowid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "last_insert_rowid", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion", + " function" + )))() +} + +pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion_number.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion_number", + " function" + )))() +} + +pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mprintf( + arg1: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mprintf", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_open( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_open16( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_prepare( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_profile( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).profile.expect(stringify!( + "sqlite3_api contains null pointer for ", + "profile", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).progress_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "progress_handler", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_double", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_null", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16be", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16le", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_value", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).rollback_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "rollback_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_authorizer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_authorizer", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_auxdata", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_snprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).snprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "snprintf", + " function" + )))(arg1, arg2, arg3, vararg1) +} + +pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "step", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_table_column_metadata( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).table_column_metadata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "table_column_metadata", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) +} + +pub unsafe fn sqlite3_thread_cleanup() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).thread_cleanup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "thread_cleanup", + " function" + )))() +} + +pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).total_changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "total_changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).trace.expect(stringify!( + "sqlite3_api contains null pointer for ", + "trace", + " function" + )))(arg1, xTrace, arg2) +} + +pub unsafe fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).transfer_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "transfer_bindings", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).update_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "update_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).user_data.expect(stringify!( + "sqlite3_api contains null pointer for ", + "user_data", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_blob", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_double", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_numeric_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_numeric_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16be", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16le", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vmprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vmprintf", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).overload_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "overload_function", + " function" + )))(arg1, zFuncName, nArg) +} + +pub unsafe fn sqlite3_prepare_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).clear_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "clear_bindings", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_module_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module_v2", + " function" + )))(arg1, arg2, arg3, arg4, xDestroy) +} + +pub unsafe fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_open( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_open", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) +} + +pub unsafe fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_read.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_read", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_write.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_write", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_file_control( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).file_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "file_control", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_highwater.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_highwater", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_used", + " function" + )))() +} + +pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_alloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_alloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_enter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_enter", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_leave.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_leave", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_try.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_try", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_open_v2( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open_v2", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_nomem.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_nomem", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_toobig.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_toobig", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sleep.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sleep", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_find.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_find", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_register.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_register", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_unregister.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_unregister", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xthreadsafe.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xthreadsafe", + " function" + )))() +} + +pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_code.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_code", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_test_control( + arg1: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).test_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "test_control", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).randomness.expect(stringify!( + "sqlite3_api contains null pointer for ", + "randomness", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).context_db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "context_db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_result_codes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_result_codes", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_limit( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "limit", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).next_stmt.expect(stringify!( + "sqlite3_api contains null pointer for ", + "next_stmt", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_status( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_finish.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_finish", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_init( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, +) -> *mut sqlite3_backup { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_init.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_init", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_pagecount.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_pagecount", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_remaining.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_remaining", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_step( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_step", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_compileoption_get( + arg1: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_get.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_get", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_compileoption_used( + arg1: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_used", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_function_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal, xDestroy) +} + +pub unsafe fn sqlite3_db_config( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, + vararg2: &mut i32, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_config", + " function" + )))(arg1, arg2, vararg1, vararg2) +} + +pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_mutex.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_mutex", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_db_status( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_status", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_errcode", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_log( + arg1: ::std::os::raw::c_int, + arg2: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).log.expect(stringify!( + "sqlite3_api contains null pointer for ", + "log", + " function" + )))(arg1, arg2, vararg1) +} + +pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sourceid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sourceid", + " function" + )))() +} + +pub unsafe fn sqlite3_stmt_status( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_status", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_strnicmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strnicmp.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strnicmp", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_unlock_notify( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int), + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).unlock_notify.expect(stringify!( + "sqlite3_api contains null pointer for ", + "unlock_notify", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_wal_autocheckpoint( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_autocheckpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_checkpoint( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_checkpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_checkpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_reopen( + arg1: *mut sqlite3_blob, + arg2: sqlite3_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_reopen.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_reopen", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vtab_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_config", + " function" + )))(arg1, op, vararg1) +} + +pub unsafe fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_on_conflict.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_on_conflict", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close_v2", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_db_filename( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_filename.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_filename", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_db_readonly( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_readonly.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_readonly", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errstr.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errstr", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_busy.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_busy", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stmt_readonly(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_readonly.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_readonly", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stricmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stricmp.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stricmp", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_uri_boolean( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_boolean.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_boolean", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_uri_int64( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64, +) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_uri_parameter( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_parameter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_parameter", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vsnprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vsnprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vsnprintf", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_wal_checkpoint_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_checkpoint_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_checkpoint_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub const SQLITE_DETERMINISTIC: i32 = 2048; diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs new file mode 100644 index 000000000..51fa550df --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs @@ -0,0 +1,8582 @@ +/* automatically generated by rust-bindgen */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.7.16\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3007016; +pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = + b"2013-03-18 11:39:23 66d5f2b76750f3520eb7a495f6247206758f5b90\0"; +pub const SQLITE_OK: i32 = 0; +pub const SQLITE_ERROR: i32 = 1; +pub const SQLITE_INTERNAL: i32 = 2; +pub const SQLITE_PERM: i32 = 3; +pub const SQLITE_ABORT: i32 = 4; +pub const SQLITE_BUSY: i32 = 5; +pub const SQLITE_LOCKED: i32 = 6; +pub const SQLITE_NOMEM: i32 = 7; +pub const SQLITE_READONLY: i32 = 8; +pub const SQLITE_INTERRUPT: i32 = 9; +pub const SQLITE_IOERR: i32 = 10; +pub const SQLITE_CORRUPT: i32 = 11; +pub const SQLITE_NOTFOUND: i32 = 12; +pub const SQLITE_FULL: i32 = 13; +pub const SQLITE_CANTOPEN: i32 = 14; +pub const SQLITE_PROTOCOL: i32 = 15; +pub const SQLITE_EMPTY: i32 = 16; +pub const SQLITE_SCHEMA: i32 = 17; +pub const SQLITE_TOOBIG: i32 = 18; +pub const SQLITE_CONSTRAINT: i32 = 19; +pub const SQLITE_MISMATCH: i32 = 20; +pub const SQLITE_MISUSE: i32 = 21; +pub const SQLITE_NOLFS: i32 = 22; +pub const SQLITE_AUTH: i32 = 23; +pub const SQLITE_FORMAT: i32 = 24; +pub const SQLITE_RANGE: i32 = 25; +pub const SQLITE_NOTADB: i32 = 26; +pub const SQLITE_ROW: i32 = 100; +pub const SQLITE_DONE: i32 = 101; +pub const SQLITE_IOERR_READ: i32 = 266; +pub const SQLITE_IOERR_SHORT_READ: i32 = 522; +pub const SQLITE_IOERR_WRITE: i32 = 778; +pub const SQLITE_IOERR_FSYNC: i32 = 1034; +pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; +pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; +pub const SQLITE_IOERR_FSTAT: i32 = 1802; +pub const SQLITE_IOERR_UNLOCK: i32 = 2058; +pub const SQLITE_IOERR_RDLOCK: i32 = 2314; +pub const SQLITE_IOERR_DELETE: i32 = 2570; +pub const SQLITE_IOERR_BLOCKED: i32 = 2826; +pub const SQLITE_IOERR_NOMEM: i32 = 3082; +pub const SQLITE_IOERR_ACCESS: i32 = 3338; +pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; +pub const SQLITE_IOERR_LOCK: i32 = 3850; +pub const SQLITE_IOERR_CLOSE: i32 = 4106; +pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; +pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; +pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; +pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; +pub const SQLITE_IOERR_SHMMAP: i32 = 5386; +pub const SQLITE_IOERR_SEEK: i32 = 5642; +pub const SQLITE_IOERR_DELETE_NOENT: i32 = 5898; +pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; +pub const SQLITE_BUSY_RECOVERY: i32 = 261; +pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; +pub const SQLITE_CANTOPEN_ISDIR: i32 = 526; +pub const SQLITE_CANTOPEN_FULLPATH: i32 = 782; +pub const SQLITE_CORRUPT_VTAB: i32 = 267; +pub const SQLITE_READONLY_RECOVERY: i32 = 264; +pub const SQLITE_READONLY_CANTLOCK: i32 = 520; +pub const SQLITE_READONLY_ROLLBACK: i32 = 776; +pub const SQLITE_ABORT_ROLLBACK: i32 = 516; +pub const SQLITE_CONSTRAINT_CHECK: i32 = 275; +pub const SQLITE_CONSTRAINT_COMMITHOOK: i32 = 531; +pub const SQLITE_CONSTRAINT_FOREIGNKEY: i32 = 787; +pub const SQLITE_CONSTRAINT_FUNCTION: i32 = 1043; +pub const SQLITE_CONSTRAINT_NOTNULL: i32 = 1299; +pub const SQLITE_CONSTRAINT_PRIMARYKEY: i32 = 1555; +pub const SQLITE_CONSTRAINT_TRIGGER: i32 = 1811; +pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067; +pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323; +pub const SQLITE_OPEN_READONLY: i32 = 1; +pub const SQLITE_OPEN_READWRITE: i32 = 2; +pub const SQLITE_OPEN_CREATE: i32 = 4; +pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; +pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; +pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; +pub const SQLITE_OPEN_URI: i32 = 64; +pub const SQLITE_OPEN_MEMORY: i32 = 128; +pub const SQLITE_OPEN_MAIN_DB: i32 = 256; +pub const SQLITE_OPEN_TEMP_DB: i32 = 512; +pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; +pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; +pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; +pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; +pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; +pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; +pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; +pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; +pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; +pub const SQLITE_OPEN_WAL: i32 = 524288; +pub const SQLITE_IOCAP_ATOMIC: i32 = 1; +pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; +pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; +pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; +pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; +pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; +pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; +pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; +pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; +pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; +pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; +pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; +pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE: i32 = 4096; +pub const SQLITE_LOCK_NONE: i32 = 0; +pub const SQLITE_LOCK_SHARED: i32 = 1; +pub const SQLITE_LOCK_RESERVED: i32 = 2; +pub const SQLITE_LOCK_PENDING: i32 = 3; +pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; +pub const SQLITE_SYNC_NORMAL: i32 = 2; +pub const SQLITE_SYNC_FULL: i32 = 3; +pub const SQLITE_SYNC_DATAONLY: i32 = 16; +pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; +pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_LAST_ERRNO: i32 = 4; +pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; +pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; +pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; +pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; +pub const SQLITE_FCNTL_WIN32_AV_RETRY: i32 = 9; +pub const SQLITE_FCNTL_PERSIST_WAL: i32 = 10; +pub const SQLITE_FCNTL_OVERWRITE: i32 = 11; +pub const SQLITE_FCNTL_VFSNAME: i32 = 12; +pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE: i32 = 13; +pub const SQLITE_FCNTL_PRAGMA: i32 = 14; +pub const SQLITE_FCNTL_BUSYHANDLER: i32 = 15; +pub const SQLITE_FCNTL_TEMPFILENAME: i32 = 16; +pub const SQLITE_ACCESS_EXISTS: i32 = 0; +pub const SQLITE_ACCESS_READWRITE: i32 = 1; +pub const SQLITE_ACCESS_READ: i32 = 2; +pub const SQLITE_SHM_UNLOCK: i32 = 1; +pub const SQLITE_SHM_LOCK: i32 = 2; +pub const SQLITE_SHM_SHARED: i32 = 4; +pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; +pub const SQLITE_SHM_NLOCK: i32 = 8; +pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; +pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; +pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; +pub const SQLITE_CONFIG_MALLOC: i32 = 4; +pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; +pub const SQLITE_CONFIG_SCRATCH: i32 = 6; +pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; +pub const SQLITE_CONFIG_HEAP: i32 = 8; +pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; +pub const SQLITE_CONFIG_MUTEX: i32 = 10; +pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; +pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; +pub const SQLITE_CONFIG_PCACHE: i32 = 14; +pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; +pub const SQLITE_CONFIG_LOG: i32 = 16; +pub const SQLITE_CONFIG_URI: i32 = 17; +pub const SQLITE_CONFIG_PCACHE2: i32 = 18; +pub const SQLITE_CONFIG_GETPCACHE2: i32 = 19; +pub const SQLITE_CONFIG_COVERING_INDEX_SCAN: i32 = 20; +pub const SQLITE_CONFIG_SQLLOG: i32 = 21; +pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; +pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; +pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; +pub const SQLITE_DENY: i32 = 1; +pub const SQLITE_IGNORE: i32 = 2; +pub const SQLITE_CREATE_INDEX: i32 = 1; +pub const SQLITE_CREATE_TABLE: i32 = 2; +pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; +pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; +pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; +pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; +pub const SQLITE_CREATE_TRIGGER: i32 = 7; +pub const SQLITE_CREATE_VIEW: i32 = 8; +pub const SQLITE_DELETE: i32 = 9; +pub const SQLITE_DROP_INDEX: i32 = 10; +pub const SQLITE_DROP_TABLE: i32 = 11; +pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; +pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; +pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; +pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; +pub const SQLITE_DROP_TRIGGER: i32 = 16; +pub const SQLITE_DROP_VIEW: i32 = 17; +pub const SQLITE_INSERT: i32 = 18; +pub const SQLITE_PRAGMA: i32 = 19; +pub const SQLITE_READ: i32 = 20; +pub const SQLITE_SELECT: i32 = 21; +pub const SQLITE_TRANSACTION: i32 = 22; +pub const SQLITE_UPDATE: i32 = 23; +pub const SQLITE_ATTACH: i32 = 24; +pub const SQLITE_DETACH: i32 = 25; +pub const SQLITE_ALTER_TABLE: i32 = 26; +pub const SQLITE_REINDEX: i32 = 27; +pub const SQLITE_ANALYZE: i32 = 28; +pub const SQLITE_CREATE_VTABLE: i32 = 29; +pub const SQLITE_DROP_VTABLE: i32 = 30; +pub const SQLITE_FUNCTION: i32 = 31; +pub const SQLITE_SAVEPOINT: i32 = 32; +pub const SQLITE_COPY: i32 = 0; +pub const SQLITE_LIMIT_LENGTH: i32 = 0; +pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; +pub const SQLITE_LIMIT_COLUMN: i32 = 2; +pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; +pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; +pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; +pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; +pub const SQLITE_LIMIT_ATTACHED: i32 = 7; +pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; +pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; +pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; +pub const SQLITE_INTEGER: i32 = 1; +pub const SQLITE_FLOAT: i32 = 2; +pub const SQLITE_BLOB: i32 = 4; +pub const SQLITE_NULL: i32 = 5; +pub const SQLITE_TEXT: i32 = 3; +pub const SQLITE3_TEXT: i32 = 3; +pub const SQLITE_UTF8: i32 = 1; +pub const SQLITE_UTF16LE: i32 = 2; +pub const SQLITE_UTF16BE: i32 = 3; +pub const SQLITE_UTF16: i32 = 4; +pub const SQLITE_ANY: i32 = 5; +pub const SQLITE_UTF16_ALIGNED: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; +pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; +pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; +pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; +pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; +pub const SQLITE_MUTEX_FAST: i32 = 0; +pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; +pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; +pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; +pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; +pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; +pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; +pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; +pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; +pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; +pub const SQLITE_TESTCTRL_FIRST: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; +pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; +pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; +pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; +pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; +pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; +pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; +pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; +pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; +pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; +pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; +pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 17; +pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 18; +pub const SQLITE_TESTCTRL_EXPLAIN_STMT: i32 = 19; +pub const SQLITE_TESTCTRL_LAST: i32 = 19; +pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; +pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; +pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; +pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; +pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; +pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; +pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; +pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; +pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; +pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; +pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; +pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; +pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; +pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; +pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; +pub const SQLITE_DBSTATUS_CACHE_HIT: i32 = 7; +pub const SQLITE_DBSTATUS_CACHE_MISS: i32 = 8; +pub const SQLITE_DBSTATUS_CACHE_WRITE: i32 = 9; +pub const SQLITE_DBSTATUS_MAX: i32 = 9; +pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; +pub const SQLITE_STMTSTATUS_SORT: i32 = 2; +pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; +pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; +pub const SQLITE_CHECKPOINT_FULL: i32 = 1; +pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; +pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; +pub const SQLITE_ROLLBACK: i32 = 1; +pub const SQLITE_FAIL: i32 = 3; +pub const SQLITE_REPLACE: i32 = 5; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; +extern "C" { + #[link_name = "\u{1}sqlite3_version"] + pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3 { + _unused: [u8; 0], +} +pub type sqlite_int64 = ::std::os::raw::c_longlong; +pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; +pub type sqlite3_int64 = sqlite_int64; +pub type sqlite3_uint64 = sqlite_uint64; +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_file { + pub pMethods: *const sqlite3_io_methods, +} +#[test] +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xShmMap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iPg: ::std::os::raw::c_int, + pgsz: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xShmLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + offset: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xShmBarrier: ::std::option::Option, + pub xShmUnmap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + deleteFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 136usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmMap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmBarrier) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmUnmap) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +pub type sqlite3_syscall_ptr = ::std::option::Option; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vfs { + pub iVersion: ::std::os::raw::c_int, + pub szOsFile: ::std::os::raw::c_int, + pub mxPathname: ::std::os::raw::c_int, + pub pNext: *mut sqlite3_vfs, + pub zName: *const ::std::os::raw::c_char, + pub pAppData: *mut ::std::os::raw::c_void, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTimeInt64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xSetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: sqlite3_syscall_ptr, + ) -> ::std::os::raw::c_int, + >, + pub xGetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> sqlite3_syscall_ptr, + >, + pub xNextSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_vfs() { + assert_eq!( + ::std::mem::size_of::(), + 168usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTimeInt64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xNextSystemCall) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mem_methods { + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub pAppData: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_mem_methods() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_stmt { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Mem { + _unused: [u8; 0], +} +pub type sqlite3_value = Mem; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_context { + _unused: [u8; 0], +} +pub type sqlite3_destructor_type = + ::std::option::Option; +extern "C" { + #[link_name = "\u{1}sqlite3_temp_directory"] + pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; +} +extern "C" { + #[link_name = "\u{1}sqlite3_data_directory"] + pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSavepoint: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRelease: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRollbackTo: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 184usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSavepoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRelease) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollbackTo) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info { + pub nConstraint: ::std::os::raw::c_int, + pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, + pub nOrderBy: ::std::os::raw::c_int, + pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, + pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, + pub idxNum: ::std::os::raw::c_int, + pub idxStr: *mut ::std::os::raw::c_char, + pub needToFreeIdxStr: ::std::os::raw::c_int, + pub orderByConsumed: ::std::os::raw::c_int, + pub estimatedCost: f64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint { + pub iColumn: ::std::os::raw::c_int, + pub op: ::std::os::raw::c_uchar, + pub usable: ::std::os::raw::c_uchar, + pub iTermOffset: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_orderby { + pub iColumn: ::std::os::raw::c_int, + pub desc: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint_usage { + pub argvIndex: ::std::os::raw::c_int, + pub omit: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); +} +#[test] +fn bindgen_test_layout_sqlite3_index_info() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_blob { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex_methods { + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_mutex_methods() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_page { + pub pBuf: *mut ::std::os::raw::c_void, + pub pExtra: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_page() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pBuf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pExtra) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods2 { + pub iVersion: ::std::os::raw::c_int, + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + szExtra: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache_page, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, + pub xShrink: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods2() { + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iVersion as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDestroy as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShrink) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods { + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_backup { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_geometry { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut f64, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_geometry() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(xDelUser) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_api_routines { + pub aggregate_context: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub aggregate_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, + >, + pub bind_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_double: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int, + >, + pub bind_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, + ) -> ::std::os::raw::c_int, + >, + pub bind_null: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub bind_parameter_index: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub bind_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub busy_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub busy_timeout: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub changes: + ::std::option::Option ::std::os::raw::c_int>, + pub close: + ::std::option::Option ::std::os::raw::c_int>, + pub collation_needed: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub collation_needed16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub column_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_bytes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_bytes16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub column_database_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_database_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_decltype: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_decltype16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_double: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, + >, + pub column_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_int64: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, + >, + pub column_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_origin_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_origin_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_table_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_table_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar, + >, + pub column_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_type: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value, + >, + pub commit_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub complete: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub complete16: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub create_collation: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_collation16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_function16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_module: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub data_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub db_handle: + ::std::option::Option *mut sqlite3>, + pub declare_vtab: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub enable_shared_cache: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub errmsg: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, + >, + pub errmsg16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, + >, + pub exec: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub expired: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub finalize: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub free: ::std::option::Option, + pub free_table: + ::std::option::Option, + pub get_autocommit: + ::std::option::Option ::std::os::raw::c_int>, + pub get_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub get_table: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub global_recover: ::std::option::Option ::std::os::raw::c_int>, + pub interruptx: ::std::option::Option, + pub last_insert_rowid: + ::std::option::Option sqlite_int64>, + pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, + pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, + pub malloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub mprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub open16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub prepare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub profile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub progress_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ), + >, + pub realloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub result_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_double: + ::std::option::Option, + pub result_error: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_error16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_int64: + ::std::option::Option, + pub result_null: ::std::option::Option, + pub result_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16be: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16le: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_value: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), + >, + pub rollback_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub set_authorizer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub set_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, + ), + >, + pub snprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub step: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub table_column_metadata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub thread_cleanup: ::std::option::Option, + pub total_changes: + ::std::option::Option ::std::os::raw::c_int>, + pub trace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub transfer_bindings: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int, + >, + pub update_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub user_data: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, + >, + pub value_blob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_bytes16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_double: ::std::option::Option f64>, + pub value_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_int64: + ::std::option::Option sqlite_int64>, + pub value_numeric_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_text: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, + >, + pub value_text16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16be: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16le: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub vmprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub overload_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub prepare_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub clear_bindings: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub create_module_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_close: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int, + >, + pub blob_read: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_write: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub create_collation_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub file_control: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub memory_highwater: + ::std::option::Option sqlite3_int64>, + pub memory_used: ::std::option::Option sqlite3_int64>, + pub mutex_alloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub mutex_enter: ::std::option::Option, + pub mutex_free: ::std::option::Option, + pub mutex_leave: ::std::option::Option, + pub mutex_try: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub open_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub release_memory: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub result_error_nomem: ::std::option::Option, + pub result_error_toobig: + ::std::option::Option, + pub sleep: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub soft_heap_limit: ::std::option::Option, + pub vfs_find: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, + >, + pub vfs_register: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub vfs_unregister: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, + >, + pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, + pub result_zeroblob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_error_code: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub test_control: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, + >, + pub randomness: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), + >, + pub context_db_handle: + ::std::option::Option *mut sqlite3>, + pub extended_result_codes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub limit: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub next_stmt: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, + >, + pub sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, + >, + pub status: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub backup_finish: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_init: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, + ) -> *mut sqlite3_backup, + >, + pub backup_pagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_remaining: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_step: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub compileoption_get: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, + >, + pub compileoption_used: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub create_function_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub db_config: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int, + >, + pub db_mutex: + ::std::option::Option *mut sqlite3_mutex>, + pub db_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub extended_errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub log: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char, ...), + >, + pub soft_heap_limit64: + ::std::option::Option sqlite3_int64>, + pub sourceid: ::std::option::Option *const ::std::os::raw::c_char>, + pub stmt_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub strnicmp: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub unlock_notify: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub wal_autocheckpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub wal_checkpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub wal_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub blob_reopen: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob, arg2: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub vtab_config: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int, + >, + pub vtab_on_conflict: + ::std::option::Option ::std::os::raw::c_int>, + pub close_v2: + ::std::option::Option ::std::os::raw::c_int>, + pub db_filename: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, + pub db_readonly: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub db_release_memory: + ::std::option::Option ::std::os::raw::c_int>, + pub errstr: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, + >, + pub stmt_busy: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub stmt_readonly: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub stricmp: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub uri_boolean: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub uri_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64, + ) -> sqlite3_int64, + >, + pub uri_parameter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, + pub vsnprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub wal_checkpoint_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_api_routines() { + assert_eq!( + ::std::mem::size_of::(), + 1536usize, + concat!("Size of: ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_context as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_context) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_count as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_double as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_count as *const _ + as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_index as *const _ + as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_index) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_name as *const _ + as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text16 as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_handler as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_handler) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_timeout as *const _ as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_timeout) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed as *const _ as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_blob as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes as *const _ as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize + }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_count as *const _ as usize + }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name as *const _ + as usize + }, + 184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name16 as *const _ + as usize + }, + 192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype as *const _ as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize + }, + 208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_double as *const _ as usize + }, + 216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, + 224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_int64 as *const _ as usize + }, + 232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name as *const _ as usize + }, + 240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name16 as *const _ as usize + }, + 248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name as *const _ as usize + }, + 256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name16 as *const _ + as usize + }, + 264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name as *const _ as usize + }, + 272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name16 as *const _ + as usize + }, + 280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text as *const _ as usize + }, + 288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text16 as *const _ as usize + }, + 296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_type as *const _ as usize + }, + 304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_type) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_value as *const _ as usize + }, + 312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).commit_hook as *const _ as usize + }, + 320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(commit_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, + 328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, + 336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation as *const _ as usize + }, + 344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation16 as *const _ as usize + }, + 352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function as *const _ as usize + }, + 360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function16 as *const _ as usize + }, + 368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module as *const _ as usize + }, + 376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, + 384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(data_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, + 392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).declare_vtab as *const _ as usize + }, + 400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(declare_vtab) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).enable_shared_cache as *const _ + as usize + }, + 408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(enable_shared_cache) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, + 416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, + 424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, + 432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, + 440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(exec) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, + 448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(expired) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, + 456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(finalize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, + 464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, + 472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_autocommit as *const _ as usize + }, + 480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_autocommit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_auxdata as *const _ as usize + }, + 488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, + 496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).global_recover as *const _ as usize + }, + 504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(global_recover) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, + 512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(interruptx) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize + }, + 520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(last_insert_rowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, + 528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).libversion_number as *const _ as usize + }, + 536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion_number) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, + 544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, + 552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, + 560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, + 568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, + 576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, + 584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, + 592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(profile) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).progress_handler as *const _ as usize + }, + 600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(progress_handler) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, + 608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, + 616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob as *const _ as usize + }, + 624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_double as *const _ as usize + }, + 632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_double) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error as *const _ as usize + }, + 640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error16 as *const _ as usize + }, + 648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, + 656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_int64 as *const _ as usize + }, + 664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_null as *const _ as usize + }, + 672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text as *const _ as usize + }, + 680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16 as *const _ as usize + }, + 688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16be as *const _ as usize + }, + 696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16le as *const _ as usize + }, + 704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16le) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_value as *const _ as usize + }, + 712usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rollback_hook as *const _ as usize + }, + 720usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(rollback_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_authorizer as *const _ as usize + }, + 728usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_authorizer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_auxdata as *const _ as usize + }, + 736usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).snprintf as *const _ as usize }, + 744usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(snprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, + 752usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).table_column_metadata as *const _ + as usize + }, + 760usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(table_column_metadata) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize + }, + 768usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(thread_cleanup) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).total_changes as *const _ as usize + }, + 776usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(total_changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, + 784usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(trace) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize + }, + 792usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(transfer_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).update_hook as *const _ as usize + }, + 800usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(update_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, + 808usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(user_data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, + 816usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes as *const _ as usize + }, + 824usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize + }, + 832usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_double as *const _ as usize + }, + 840usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, + 848usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_int64 as *const _ as usize + }, + 856usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize + }, + 864usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_numeric_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, + 872usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16 as *const _ as usize + }, + 880usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16be as *const _ as usize + }, + 888usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16le as *const _ as usize + }, + 896usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16le) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, + 904usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, + 912usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vmprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).overload_function as *const _ as usize + }, + 920usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(overload_function) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, + 928usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize + }, + 936usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).clear_bindings as *const _ as usize + }, + 944usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(clear_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize + }, + 952usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize + }, + 960usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, + 968usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_bytes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, + 976usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_close) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, + 984usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, + 992usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_read) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, + 1000usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_write) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation_v2 as *const _ + as usize + }, + 1008usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).file_control as *const _ as usize + }, + 1016usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(file_control) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_highwater as *const _ as usize + }, + 1024usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_highwater) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_used as *const _ as usize + }, + 1032usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize + }, + 1040usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_alloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_enter as *const _ as usize + }, + 1048usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_enter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, + 1056usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_leave as *const _ as usize + }, + 1064usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_leave) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, + 1072usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_try) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, + 1080usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).release_memory as *const _ as usize + }, + 1088usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(release_memory) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize + }, + 1096usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_nomem) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_toobig as *const _ + as usize + }, + 1104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_toobig) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, + 1112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sleep) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize + }, + 1120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, + 1128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_find) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_register as *const _ as usize + }, + 1136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_register) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize + }, + 1144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_unregister) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize + }, + 1152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xthreadsafe) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize + }, + 1160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_code as *const _ as usize + }, + 1168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_code) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).test_control as *const _ as usize + }, + 1176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(test_control) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, + 1184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(randomness) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).context_db_handle as *const _ as usize + }, + 1192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(context_db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_result_codes as *const _ + as usize + }, + 1200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_result_codes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, + 1208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, + 1216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(next_stmt) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, + 1224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sql) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, + 1232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_finish as *const _ as usize + }, + 1240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_finish) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_init as *const _ as usize + }, + 1248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_init) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_pagecount as *const _ as usize + }, + 1256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_pagecount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_remaining as *const _ as usize + }, + 1264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_remaining) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_step as *const _ as usize + }, + 1272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_get as *const _ as usize + }, + 1280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_get) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_used as *const _ as usize + }, + 1288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function_v2 as *const _ as usize + }, + 1296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function_v2) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_config as *const _ as usize }, + 1304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_config) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_mutex as *const _ as usize }, + 1312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_mutex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_status as *const _ as usize }, + 1320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_errcode as *const _ as usize + }, + 1328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).log as *const _ as usize }, + 1336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(log) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit64 as *const _ as usize + }, + 1344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sourceid as *const _ as usize }, + 1352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sourceid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stmt_status as *const _ as usize + }, + 1360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_status) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strnicmp as *const _ as usize }, + 1368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strnicmp) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).unlock_notify as *const _ as usize + }, + 1376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(unlock_notify) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_autocheckpoint as *const _ as usize + }, + 1384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_autocheckpoint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_checkpoint as *const _ as usize + }, + 1392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_checkpoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).wal_hook as *const _ as usize }, + 1400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).blob_reopen as *const _ as usize + }, + 1408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_reopen) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_config as *const _ as usize + }, + 1416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_config) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_on_conflict as *const _ as usize + }, + 1424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_on_conflict) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close_v2 as *const _ as usize }, + 1432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_filename as *const _ as usize + }, + 1440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_filename) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_readonly as *const _ as usize + }, + 1448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_readonly) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_release_memory as *const _ as usize + }, + 1456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_release_memory) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errstr as *const _ as usize }, + 1464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errstr) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).stmt_busy as *const _ as usize }, + 1472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_busy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stmt_readonly as *const _ as usize + }, + 1480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_readonly) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).stricmp as *const _ as usize }, + 1488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stricmp) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).uri_boolean as *const _ as usize + }, + 1496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_boolean) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).uri_int64 as *const _ as usize }, + 1504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).uri_parameter as *const _ as usize + }, + 1512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_parameter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vsnprintf as *const _ as usize }, + 1520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vsnprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_checkpoint_v2 as *const _ as usize + }, + 1528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_checkpoint_v2) + ) + ); +} +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} + +// bindings were built with (non-embedded) loadable_extension: +// we define our own sqlite_api static variable and export it +// to C +#[no_mangle] +pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_routines; + +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) + +pub unsafe fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_context.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_context", + " function" + )))(arg1, nBytes) +} + +pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_double", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_null", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_index.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_index", + " function" + )))(arg1, zName) +} + +pub unsafe fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_value", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_handler", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_timeout.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_timeout", + " function" + )))(arg1, ms) +} + +pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_blob", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype", + " function" + )))(arg1, i) +} + +pub unsafe fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_double", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int64", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_type", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_value", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).commit_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "commit_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete16", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_create_collation( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_collation16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_function( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_function16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function16", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_module( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).data_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "data_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).declare_vtab.expect(stringify!( + "sqlite3_api contains null pointer for ", + "declare_vtab", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).enable_shared_cache.expect(stringify!( + "sqlite3_api contains null pointer for ", + "enable_shared_cache", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errcode", + " function" + )))(db) +} + +pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_exec( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).exec.expect(stringify!( + "sqlite3_api contains null pointer for ", + "exec", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).expired.expect(stringify!( + "sqlite3_api contains null pointer for ", + "expired", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).finalize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "finalize", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free_table", + " function" + )))(result) +} + +pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_autocommit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_autocommit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_auxdata", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_get_table( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_table", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).global_recover.expect(stringify!( + "sqlite3_api contains null pointer for ", + "global_recover", + " function" + )))() +} + +pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).interruptx.expect(stringify!( + "sqlite3_api contains null pointer for ", + "interruptx", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).last_insert_rowid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "last_insert_rowid", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion", + " function" + )))() +} + +pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion_number.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion_number", + " function" + )))() +} + +pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mprintf( + arg1: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mprintf", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_open( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_open16( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_prepare( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_profile( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).profile.expect(stringify!( + "sqlite3_api contains null pointer for ", + "profile", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).progress_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "progress_handler", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_double", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_null", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16be", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16le", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_value", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).rollback_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "rollback_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_authorizer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_authorizer", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_auxdata", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_snprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).snprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "snprintf", + " function" + )))(arg1, arg2, arg3, vararg1) +} + +pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "step", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_table_column_metadata( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).table_column_metadata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "table_column_metadata", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) +} + +pub unsafe fn sqlite3_thread_cleanup() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).thread_cleanup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "thread_cleanup", + " function" + )))() +} + +pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).total_changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "total_changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).trace.expect(stringify!( + "sqlite3_api contains null pointer for ", + "trace", + " function" + )))(arg1, xTrace, arg2) +} + +pub unsafe fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).transfer_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "transfer_bindings", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).update_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "update_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).user_data.expect(stringify!( + "sqlite3_api contains null pointer for ", + "user_data", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_blob", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_double", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_numeric_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_numeric_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16be", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16le", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vmprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vmprintf", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).overload_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "overload_function", + " function" + )))(arg1, zFuncName, nArg) +} + +pub unsafe fn sqlite3_prepare_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).clear_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "clear_bindings", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_module_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module_v2", + " function" + )))(arg1, arg2, arg3, arg4, xDestroy) +} + +pub unsafe fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_open( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_open", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) +} + +pub unsafe fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_read.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_read", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_write.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_write", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_file_control( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).file_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "file_control", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_highwater.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_highwater", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_used", + " function" + )))() +} + +pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_alloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_alloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_enter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_enter", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_leave.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_leave", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_try.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_try", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_open_v2( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open_v2", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_nomem.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_nomem", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_toobig.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_toobig", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sleep.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sleep", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_find.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_find", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_register.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_register", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_unregister.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_unregister", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xthreadsafe.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xthreadsafe", + " function" + )))() +} + +pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_code.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_code", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_test_control( + arg1: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).test_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "test_control", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).randomness.expect(stringify!( + "sqlite3_api contains null pointer for ", + "randomness", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).context_db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "context_db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_result_codes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_result_codes", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_limit( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "limit", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).next_stmt.expect(stringify!( + "sqlite3_api contains null pointer for ", + "next_stmt", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_status( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_finish.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_finish", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_init( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, +) -> *mut sqlite3_backup { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_init.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_init", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_pagecount.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_pagecount", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_remaining.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_remaining", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_step( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_step", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_compileoption_get( + arg1: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_get.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_get", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_compileoption_used( + arg1: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_used", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_function_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal, xDestroy) +} + +pub unsafe fn sqlite3_db_config( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, + vararg2: &mut i32, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_config", + " function" + )))(arg1, arg2, vararg1, vararg2) +} + +pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_mutex.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_mutex", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_db_status( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_status", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_errcode", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_log( + arg1: ::std::os::raw::c_int, + arg2: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).log.expect(stringify!( + "sqlite3_api contains null pointer for ", + "log", + " function" + )))(arg1, arg2, vararg1) +} + +pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sourceid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sourceid", + " function" + )))() +} + +pub unsafe fn sqlite3_stmt_status( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_status", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_strnicmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strnicmp.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strnicmp", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_unlock_notify( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int), + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).unlock_notify.expect(stringify!( + "sqlite3_api contains null pointer for ", + "unlock_notify", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_wal_autocheckpoint( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_autocheckpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_checkpoint( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_checkpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_checkpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_reopen( + arg1: *mut sqlite3_blob, + arg2: sqlite3_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_reopen.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_reopen", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vtab_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_config", + " function" + )))(arg1, op, vararg1) +} + +pub unsafe fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_on_conflict.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_on_conflict", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close_v2", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_db_filename( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_filename.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_filename", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_db_readonly( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_readonly.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_readonly", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errstr.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errstr", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_busy.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_busy", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stmt_readonly(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_readonly.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_readonly", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stricmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stricmp.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stricmp", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_uri_boolean( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_boolean.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_boolean", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_uri_int64( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64, +) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_uri_parameter( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_parameter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_parameter", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vsnprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vsnprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vsnprintf", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_wal_checkpoint_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_checkpoint_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_checkpoint_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub const SQLITE_DETERMINISTIC: i32 = 2048; diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16.rs index cd1489511..095987694 100644 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16.rs +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16.rs @@ -1,10 +1,10 @@ /* automatically generated by rust-bindgen */ pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.7.16\x00"; +pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.7.16\0"; pub const SQLITE_VERSION_NUMBER: i32 = 3007016; pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = - b"2013-03-18 11:39:23 66d5f2b76750f3520eb7a495f6247206758f5b90\x00"; + b"2013-03-18 11:39:23 66d5f2b76750f3520eb7a495f6247206758f5b90\0"; pub const SQLITE_OK: i32 = 0; pub const SQLITE_ERROR: i32 = 1; pub const SQLITE_INTERNAL: i32 = 2; @@ -289,7 +289,7 @@ pub const SQLITE_REPLACE: i32 = 5; pub type va_list = __builtin_va_list; pub type __gnuc_va_list = __builtin_va_list; extern "C" { - #[link_name = "sqlite3_version"] + #[link_name = "\u{1}sqlite3_version"] pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; } extern "C" { @@ -302,19 +302,21 @@ extern "C" { pub fn sqlite3_libversion_number() -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_compileoption_used(zOptName: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_compileoption_used( + zOptName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_compileoption_get(N: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_compileoption_get(N: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; } extern "C" { pub fn sqlite3_threadsafe() -> ::std::os::raw::c_int; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3([u8; 0]); +pub struct sqlite3 { + _unused: [u8; 0], +} pub type sqlite_int64 = ::std::os::raw::c_longlong; pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; pub type sqlite3_int64 = sqlite_int64; @@ -325,160 +327,348 @@ extern "C" { extern "C" { pub fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int; } -pub type sqlite3_callback = - ::std::option::Option ::std::os::raw::c_int>; -extern "C" { - pub fn sqlite3_exec(arg1: *mut sqlite3, - sql: *const ::std::os::raw::c_char, - callback: - ::std::option::Option - ::std::os::raw::c_int>, - arg2: *mut ::std::os::raw::c_void, - errmsg: *mut *mut ::std::os::raw::c_char) - -> ::std::os::raw::c_int; +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +extern "C" { + pub fn sqlite3_exec( + arg1: *mut sqlite3, + sql: *const ::std::os::raw::c_char, + callback: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg2: *mut ::std::os::raw::c_void, + errmsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_file { - pub pMethods: *const sqlite3_file_sqlite3_io_methods, -} -#[repr(C)] -#[derive(Debug, Copy)] -pub struct sqlite3_file_sqlite3_io_methods { - pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option ::std::os::raw::c_int>, - pub xRead: ::std::option::Option ::std::os::raw::c_int>, - pub xWrite: ::std::option::Option ::std::os::raw::c_int>, - pub xTruncate: ::std::option::Option ::std::os::raw::c_int>, - pub xSync: ::std::option::Option ::std::os::raw::c_int>, - pub xFileSize: ::std::option::Option ::std::os::raw::c_int>, - pub xLock: ::std::option::Option ::std::os::raw::c_int>, - pub xUnlock: ::std::option::Option ::std::os::raw::c_int>, - pub xCheckReservedLock: ::std::option::Option - ::std::os::raw::c_int>, - pub xFileControl: ::std::option::Option ::std::os::raw::c_int>, - pub xSectorSize: ::std::option::Option ::std::os::raw::c_int>, - pub xDeviceCharacteristics: ::std::option::Option - ::std::os::raw::c_int>, - pub xShmMap: ::std::option::Option ::std::os::raw::c_int>, - pub xShmLock: ::std::option::Option ::std::os::raw::c_int>, - pub xShmBarrier: ::std::option::Option, - pub xShmUnmap: ::std::option::Option ::std::os::raw::c_int>, + pub pMethods: *const sqlite3_io_methods, } #[test] -fn bindgen_test_layout_sqlite3_file_sqlite3_io_methods() { - assert_eq!(::std::mem::size_of::() , - 136usize); - assert_eq!(::std::mem::align_of::() , - 8usize); +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); } -impl Clone for sqlite3_file_sqlite3_io_methods { - fn clone(&self) -> Self { *self } +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xShmMap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iPg: ::std::os::raw::c_int, + pgsz: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xShmLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + offset: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xShmBarrier: ::std::option::Option, + pub xShmUnmap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + deleteFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, } #[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!(::std::mem::size_of::() , 8usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_file { - fn clone(&self) -> Self { *self } +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 136usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmMap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmBarrier) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmUnmap) + ) + ); } -pub type sqlite3_io_methods = sqlite3_file_sqlite3_io_methods; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex([u8; 0]); +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +pub type sqlite3_syscall_ptr = ::std::option::Option; #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_vfs { pub iVersion: ::std::os::raw::c_int, pub szOsFile: ::std::os::raw::c_int, @@ -486,124 +676,349 @@ pub struct sqlite3_vfs { pub pNext: *mut sqlite3_vfs, pub zName: *const ::std::os::raw::c_char, pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option ::std::os::raw::c_int>, - pub xDelete: ::std::option::Option ::std::os::raw::c_int>, - pub xAccess: ::std::option::Option ::std::os::raw::c_int>, - pub xFullPathname: ::std::option::Option ::std::os::raw::c_int>, - pub xDlOpen: ::std::option::Option *mut ::std::os::raw::c_void>, - pub xDlError: ::std::option::Option, - pub xDlSym: ::std::option::Option - ::std::option::Option>, - pub xDlClose: ::std::option::Option, - pub xRandomness: ::std::option::Option ::std::os::raw::c_int>, - pub xSleep: ::std::option::Option ::std::os::raw::c_int>, - pub xCurrentTime: ::std::option::Option ::std::os::raw::c_int>, - pub xGetLastError: ::std::option::Option ::std::os::raw::c_int>, - pub xCurrentTimeInt64: ::std::option::Option - ::std::os::raw::c_int>, - pub xSetSystemCall: ::std::option::Option ::std::os::raw::c_int>, - pub xGetSystemCall: ::std::option::Option - ::std::option::Option>, - pub xNextSystemCall: ::std::option::Option - *const ::std::os::raw::c_char>, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTimeInt64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xSetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: sqlite3_syscall_ptr, + ) -> ::std::os::raw::c_int, + >, + pub xGetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> sqlite3_syscall_ptr, + >, + pub xNextSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, } #[test] fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!(::std::mem::size_of::() , 168usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_vfs { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 168usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTimeInt64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xNextSystemCall) + ) + ); } -pub type sqlite3_syscall_ptr = ::std::option::Option; extern "C" { pub fn sqlite3_initialize() -> ::std::os::raw::c_int; } @@ -617,52 +1032,138 @@ extern "C" { pub fn sqlite3_os_end() -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) - -> ::std::os::raw::c_int; + pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_db_config(arg1: *mut sqlite3, - op: ::std::os::raw::c_int, ...) - -> ::std::os::raw::c_int; + pub fn sqlite3_db_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option *mut ::std::os::raw::c_void>, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option *mut ::std::os::raw::c_void>, - pub xSize: ::std::option::Option ::std::os::raw::c_int>, - pub xRoundup: ::std::option::Option ::std::os::raw::c_int>, - pub xInit: ::std::option::Option ::std::os::raw::c_int>, - pub xShutdown: ::std::option::Option, + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, pub pAppData: *mut ::std::os::raw::c_void, } #[test] fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!(::std::mem::size_of::() , 64usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_mem_methods { - fn clone(&self) -> Self { *self } -} -extern "C" { - pub fn sqlite3_extended_result_codes(arg1: *mut sqlite3, - onoff: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +extern "C" { + pub fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + onoff: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite3_int64; @@ -677,71 +1178,76 @@ extern "C" { pub fn sqlite3_interrupt(arg1: *mut sqlite3); } extern "C" { - pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_busy_handler(arg1: *mut sqlite3, - arg2: - ::std::option::Option - ::std::os::raw::c_int>, - arg3: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_busy_timeout(arg1: *mut sqlite3, ms: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_get_table(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - pazResult: *mut *mut *mut ::std::os::raw::c_char, - pnRow: *mut ::std::os::raw::c_int, - pnColumn: *mut ::std::os::raw::c_int, - pzErrmsg: *mut *mut ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_get_table( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + pazResult: *mut *mut *mut ::std::os::raw::c_char, + pnRow: *mut ::std::os::raw::c_int, + pnColumn: *mut ::std::os::raw::c_int, + pzErrmsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char); } extern "C" { pub fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char, ...) - -> *mut ::std::os::raw::c_char; + -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_vmprintf(arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag) - -> *mut ::std::os::raw::c_char; + pub fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_snprintf(arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, ...) - -> *mut ::std::os::raw::c_char; + pub fn sqlite3_snprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_vsnprintf(arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut __va_list_tag) - -> *mut ::std::os::raw::c_char; + pub fn sqlite3_vsnprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_realloc(arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; } extern "C" { pub fn sqlite3_free(arg1: *mut ::std::os::raw::c_void); @@ -750,463 +1256,487 @@ extern "C" { pub fn sqlite3_memory_used() -> sqlite3_int64; } extern "C" { - pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) - -> sqlite3_int64; + pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) -> sqlite3_int64; } extern "C" { - pub fn sqlite3_randomness(N: ::std::os::raw::c_int, - P: *mut ::std::os::raw::c_void); + pub fn sqlite3_randomness(N: ::std::os::raw::c_int, P: *mut ::std::os::raw::c_void); } extern "C" { - pub fn sqlite3_set_authorizer(arg1: *mut sqlite3, - xAuth: - ::std::option::Option - ::std::os::raw::c_int>, - pUserData: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + xAuth: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pUserData: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_trace(arg1: *mut sqlite3, - xTrace: - ::std::option::Option, - arg2: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_profile(arg1: *mut sqlite3, - xProfile: - ::std::option::Option, - arg2: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_profile( + arg1: *mut sqlite3, + xProfile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_progress_handler(arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: - ::std::option::Option - ::std::os::raw::c_int>, - arg4: *mut ::std::os::raw::c_void); + pub fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ); } extern "C" { - pub fn sqlite3_open(filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3) -> ::std::os::raw::c_int; + pub fn sqlite3_open( + filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_open16(filename: *const ::std::os::raw::c_void, - ppDb: *mut *mut sqlite3) -> ::std::os::raw::c_int; + pub fn sqlite3_open16( + filename: *const ::std::os::raw::c_void, + ppDb: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_open_v2(filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3, - flags: ::std::os::raw::c_int, - zVfs: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_open_v2( + filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3, + flags: ::std::os::raw::c_int, + zVfs: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_uri_parameter(zFilename: *const ::std::os::raw::c_char, - zParam: *const ::std::os::raw::c_char) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_uri_parameter( + zFilename: *const ::std::os::raw::c_char, + zParam: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_uri_boolean(zFile: *const ::std::os::raw::c_char, - zParam: *const ::std::os::raw::c_char, - bDefault: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_uri_boolean( + zFile: *const ::std::os::raw::c_char, + zParam: *const ::std::os::raw::c_char, + bDefault: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_uri_int64(arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_int64) -> sqlite3_int64; + pub fn sqlite3_uri_int64( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64, + ) -> sqlite3_int64; } extern "C" { pub fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_extended_errcode(db: *mut sqlite3) - -> ::std::os::raw::c_int; + pub fn sqlite3_extended_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_errmsg(arg1: *mut sqlite3) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_errmsg16(arg1: *mut sqlite3) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_errstr(arg1: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt([u8; 0]); +pub struct sqlite3_stmt { + _unused: [u8; 0], +} extern "C" { - pub fn sqlite3_limit(arg1: *mut sqlite3, id: ::std::os::raw::c_int, - newVal: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_limit( + arg1: *mut sqlite3, + id: ::std::os::raw::c_int, + newVal: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_prepare( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare_v2(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_prepare_v2( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare16(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_prepare16( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare16_v2(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_prepare16_v2( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_stmt_readonly(pStmt: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_stmt_readonly(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct Mem([u8; 0]); +pub struct Mem { + _unused: [u8; 0], +} pub type sqlite3_value = Mem; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_context([u8; 0]); +pub struct sqlite3_context { + _unused: [u8; 0], +} extern "C" { - pub fn sqlite3_bind_blob(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: - ::std::option::Option) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_double(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, arg3: f64) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_int(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_int64(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_int64) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_int64, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_null(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_text(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: - ::std::option::Option) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_text16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: - ::std::option::Option) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_value(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_zeroblob(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - n: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_parameter_name(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_bind_parameter_index(arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_name(arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_name16(arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_database_name(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_database_name16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_table_name(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_table_name16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_origin_name(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_origin_name16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_decltype(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_decltype16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { pub fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_blob(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_bytes(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_bytes16(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) -> f64; + pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64; } extern "C" { - pub fn sqlite3_column_int(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_int64(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) -> sqlite3_int64; + pub fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> sqlite3_int64; } extern "C" { - pub fn sqlite3_column_text(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_uchar; + pub fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar; } extern "C" { - pub fn sqlite3_column_text16(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_type(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_value(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> *mut sqlite3_value; + pub fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value; } extern "C" { - pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_create_function(db: *mut sqlite3, - zFunctionName: - *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: - ::std::option::Option, - xStep: - ::std::option::Option, - xFinal: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function16(db: *mut sqlite3, - zFunctionName: - *const ::std::os::raw::c_void, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: - ::std::option::Option, - xStep: - ::std::option::Option, - xFinal: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function_v2(db: *mut sqlite3, - zFunctionName: - *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: - ::std::option::Option, - xStep: - ::std::option::Option, - xFinal: - ::std::option::Option, - xDestroy: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) - -> ::std::os::raw::c_int; + pub fn sqlite3_create_function( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function16( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_void, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function_v2( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_transfer_bindings(arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_global_recover() -> ::std::os::raw::c_int; @@ -1215,111 +1745,106 @@ extern "C" { pub fn sqlite3_thread_cleanup(); } extern "C" { - pub fn sqlite3_memory_alarm(arg1: - ::std::option::Option, - arg2: *mut ::std::os::raw::c_void, - arg3: sqlite3_int64) -> ::std::os::raw::c_int; + pub fn sqlite3_memory_alarm( + arg1: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_int64, + arg3: ::std::os::raw::c_int, + ), + >, + arg2: *mut ::std::os::raw::c_void, + arg3: sqlite3_int64, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64; } extern "C" { - pub fn sqlite3_value_int(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite3_int64; } extern "C" { - pub fn sqlite3_value_text(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_uchar; + pub fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar; } extern "C" { - pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_type(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_aggregate_context(arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_user_data(arg1: *mut sqlite3_context) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) - -> *mut sqlite3; + pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3; } extern "C" { - pub fn sqlite3_get_auxdata(arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_set_auxdata(arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - arg3: - ::std::option::Option); + pub fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option, + ); } pub type sqlite3_destructor_type = - ::std::option::Option; + ::std::option::Option; extern "C" { - pub fn sqlite3_result_blob(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); + pub fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); } extern "C" { pub fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64); } extern "C" { - pub fn sqlite3_result_error(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int); + pub fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ); } extern "C" { - pub fn sqlite3_result_error16(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int); + pub fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ); } extern "C" { pub fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context); @@ -1328,229 +1853,206 @@ extern "C" { pub fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context); } extern "C" { - pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int); + pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_result_int(arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int); + pub fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, - arg2: sqlite3_int64); + pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite3_int64); } extern "C" { pub fn sqlite3_result_null(arg1: *mut sqlite3_context); } extern "C" { - pub fn sqlite3_result_text(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); -} -extern "C" { - pub fn sqlite3_result_text16(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); -} -extern "C" { - pub fn sqlite3_result_text16le(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); -} -extern "C" { - pub fn sqlite3_result_text16be(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); -} -extern "C" { - pub fn sqlite3_result_value(arg1: *mut sqlite3_context, - arg2: *mut sqlite3_value); -} -extern "C" { - pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, - n: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_create_collation(arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - xCompare: - ::std::option::Option - ::std::os::raw::c_int>) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation_v2(arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - xCompare: - ::std::option::Option - ::std::os::raw::c_int>, - xDestroy: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation16(arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_void, - eTextRep: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - xCompare: - ::std::option::Option - ::std::os::raw::c_int>) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed(arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed16(arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; -} -extern "C" { - #[link_name = "sqlite3_temp_directory"] + pub fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value); +} +extern "C" { + pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, n: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_create_collation( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation16( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_void, + eTextRep: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "\u{1}sqlite3_temp_directory"] pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; } extern "C" { - #[link_name = "sqlite3_data_directory"] + #[link_name = "\u{1}sqlite3_data_directory"] pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) - -> ::std::os::raw::c_int; + pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3; } extern "C" { - pub fn sqlite3_db_filename(db: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_db_filename( + db: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_db_readonly(db: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_db_readonly( + db: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) - -> *mut sqlite3_stmt; + pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) -> *mut sqlite3_stmt; } extern "C" { - pub fn sqlite3_commit_hook(arg1: *mut sqlite3, - arg2: - ::std::option::Option - ::std::os::raw::c_int>, - arg3: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_rollback_hook(arg1: *mut sqlite3, - arg2: - ::std::option::Option, - arg3: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_update_hook(arg1: *mut sqlite3, - arg2: - ::std::option::Option, - arg3: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_db_release_memory(arg1: *mut sqlite3) - -> ::std::os::raw::c_int; + pub fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_soft_heap_limit64(N: sqlite3_int64) -> sqlite3_int64; @@ -1559,60 +2061,418 @@ extern "C" { pub fn sqlite3_soft_heap_limit(N: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_table_column_metadata(db: *mut sqlite3, - zDbName: - *const ::std::os::raw::c_char, - zTableName: - *const ::std::os::raw::c_char, - zColumnName: - *const ::std::os::raw::c_char, - pzDataType: - *mut *const ::std::os::raw::c_char, - pzCollSeq: - *mut *const ::std::os::raw::c_char, - pNotNull: *mut ::std::os::raw::c_int, - pPrimaryKey: - *mut ::std::os::raw::c_int, - pAutoinc: *mut ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_table_column_metadata( + db: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + zTableName: *const ::std::os::raw::c_char, + zColumnName: *const ::std::os::raw::c_char, + pzDataType: *mut *const ::std::os::raw::c_char, + pzCollSeq: *mut *const ::std::os::raw::c_char, + pNotNull: *mut ::std::os::raw::c_int, + pPrimaryKey: *mut ::std::os::raw::c_int, + pAutoinc: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_load_extension(db: *mut sqlite3, - zFile: *const ::std::os::raw::c_char, - zProc: *const ::std::os::raw::c_char, - pzErrMsg: *mut *mut ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_load_extension( + db: *mut sqlite3, + zFile: *const ::std::os::raw::c_char, + zProc: *const ::std::os::raw::c_char, + pzErrMsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_enable_load_extension(db: *mut sqlite3, - onoff: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_enable_load_extension( + db: *mut sqlite3, + onoff: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_auto_extension(xEntryPoint: - ::std::option::Option) - -> ::std::os::raw::c_int; + pub fn sqlite3_auto_extension( + xEntryPoint: ::std::option::Option, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_reset_auto_extension(); } #[repr(C)] -#[derive(Debug, Copy)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSavepoint: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRelease: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRollbackTo: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, } #[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!(::std::mem::size_of::() , 24usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_vtab { - fn clone(&self) -> Self { *self } +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 184usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSavepoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRelease) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollbackTo) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_index_info { pub nConstraint: ::std::os::raw::c_int, pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, @@ -1626,7 +2486,7 @@ pub struct sqlite3_index_info { pub estimatedCost: f64, } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_index_info_sqlite3_index_constraint { pub iColumn: ::std::os::raw::c_int, pub op: ::std::os::raw::c_uchar, @@ -1635,294 +2495,464 @@ pub struct sqlite3_index_info_sqlite3_index_constraint { } #[test] fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!(::std::mem::size_of::() - , 12usize); - assert_eq!(::std::mem::align_of::() - , 4usize); -} -impl Clone for sqlite3_index_info_sqlite3_index_constraint { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_index_info_sqlite3_index_orderby { pub iColumn: ::std::os::raw::c_int, pub desc: ::std::os::raw::c_uchar, } #[test] fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!(::std::mem::size_of::() - , 8usize); - assert_eq!(::std::mem::align_of::() - , 4usize); -} -impl Clone for sqlite3_index_info_sqlite3_index_orderby { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_index_info_sqlite3_index_constraint_usage { pub argvIndex: ::std::os::raw::c_int, pub omit: ::std::os::raw::c_uchar, } #[test] fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!(::std::mem::size_of::() - , 8usize); - assert_eq!(::std::mem::align_of::() - , 4usize); -} -impl Clone for sqlite3_index_info_sqlite3_index_constraint_usage { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); } #[test] fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!(::std::mem::size_of::() , 72usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_index_info { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); +} +extern "C" { + pub fn sqlite3_create_module( + db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + p: *const sqlite3_module, + pClientData: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_module_v2( + db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + p: *const sqlite3_module, + pClientData: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy)] -pub struct sqlite3_vtab_cursor { - pub pVtab: *mut sqlite3_vtab, +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, } #[test] -fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!(::std::mem::size_of::() , 8usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_vtab_cursor { - fn clone(&self) -> Self { *self } +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option ::std::os::raw::c_int>, - pub xConnect: ::std::option::Option ::std::os::raw::c_int>, - pub xBestIndex: ::std::option::Option ::std::os::raw::c_int>, - pub xDisconnect: ::std::option::Option ::std::os::raw::c_int>, - pub xDestroy: ::std::option::Option ::std::os::raw::c_int>, - pub xOpen: ::std::option::Option ::std::os::raw::c_int>, - pub xClose: ::std::option::Option ::std::os::raw::c_int>, - pub xFilter: ::std::option::Option ::std::os::raw::c_int>, - pub xNext: ::std::option::Option ::std::os::raw::c_int>, - pub xEof: ::std::option::Option ::std::os::raw::c_int>, - pub xColumn: ::std::option::Option ::std::os::raw::c_int>, - pub xRowid: ::std::option::Option ::std::os::raw::c_int>, - pub xUpdate: ::std::option::Option ::std::os::raw::c_int>, - pub xBegin: ::std::option::Option ::std::os::raw::c_int>, - pub xSync: ::std::option::Option ::std::os::raw::c_int>, - pub xCommit: ::std::option::Option ::std::os::raw::c_int>, - pub xRollback: ::std::option::Option ::std::os::raw::c_int>, - pub xFindFunction: ::std::option::Option, - ppArg: - *mut *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int>, - pub xRename: ::std::option::Option ::std::os::raw::c_int>, - pub xSavepoint: ::std::option::Option ::std::os::raw::c_int>, - pub xRelease: ::std::option::Option ::std::os::raw::c_int>, - pub xRollbackTo: ::std::option::Option ::std::os::raw::c_int>, +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, } #[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!(::std::mem::size_of::() , 184usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_module { - fn clone(&self) -> Self { *self } -} -extern "C" { - pub fn sqlite3_create_module(db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - p: *const sqlite3_module, - pClientData: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_module_v2(db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - p: *const sqlite3_module, - pClientData: *mut ::std::os::raw::c_void, - xDestroy: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_declare_vtab(arg1: *mut sqlite3, - zSQL: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_overload_function(arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +extern "C" { + pub fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + zSQL: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob([u8; 0]); +pub struct sqlite3_blob { + _unused: [u8; 0], +} extern "C" { - pub fn sqlite3_blob_open(arg1: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - zTable: *const ::std::os::raw::c_char, - zColumn: *const ::std::os::raw::c_char, - iRow: sqlite3_int64, - flags: ::std::os::raw::c_int, - ppBlob: *mut *mut sqlite3_blob) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_open( + arg1: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + zTable: *const ::std::os::raw::c_char, + zColumn: *const ::std::os::raw::c_char, + iRow: sqlite3_int64, + flags: ::std::os::raw::c_int, + ppBlob: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_reopen(arg1: *mut sqlite3_blob, arg2: sqlite3_int64) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_reopen( + arg1: *mut sqlite3_blob, + arg2: sqlite3_int64, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_read(arg1: *mut sqlite3_blob, - Z: *mut ::std::os::raw::c_void, - N: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + Z: *mut ::std::os::raw::c_void, + N: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_write(arg1: *mut sqlite3_blob, - z: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + z: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) - -> *mut sqlite3_vfs; + pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs; } extern "C" { - pub fn sqlite3_vfs_register(arg1: *mut sqlite3_vfs, - makeDflt: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + makeDflt: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) - -> ::std::os::raw::c_int; + pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) - -> *mut sqlite3_mutex; + pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex; } extern "C" { pub fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex); @@ -1931,367 +2961,872 @@ extern "C" { pub fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex); } extern "C" { - pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) - -> ::std::os::raw::c_int; + pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option *mut sqlite3_mutex>, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexNotheld: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, } #[test] fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!(::std::mem::size_of::() , 72usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_mutex_methods { - fn clone(&self) -> Self { *self } -} -extern "C" { - pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) - -> ::std::os::raw::c_int; + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +extern "C" { + pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex; } extern "C" { - pub fn sqlite3_file_control(arg1: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - op: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_file_control( + arg1: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + op: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) - -> ::std::os::raw::c_int; + pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_status(op: ::std::os::raw::c_int, - pCurrent: *mut ::std::os::raw::c_int, - pHighwater: *mut ::std::os::raw::c_int, - resetFlag: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_status( + op: ::std::os::raw::c_int, + pCurrent: *mut ::std::os::raw::c_int, + pHighwater: *mut ::std::os::raw::c_int, + resetFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_db_status(arg1: *mut sqlite3, op: ::std::os::raw::c_int, - pCur: *mut ::std::os::raw::c_int, - pHiwtr: *mut ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_db_status( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + pCur: *mut ::std::os::raw::c_int, + pHiwtr: *mut ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_stmt_status(arg1: *mut sqlite3_stmt, - op: ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_stmt_status( + arg1: *mut sqlite3_stmt, + op: ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache([u8; 0]); +pub struct sqlite3_pcache { + _unused: [u8; 0], +} #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_pcache_page { pub pBuf: *mut ::std::os::raw::c_void, pub pExtra: *mut ::std::os::raw::c_void, } #[test] fn bindgen_test_layout_sqlite3_pcache_page() { - assert_eq!(::std::mem::size_of::() , 16usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_pcache_page { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pBuf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pExtra) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_pcache_methods2 { pub iVersion: ::std::os::raw::c_int, pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option ::std::os::raw::c_int>, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option *mut sqlite3_pcache>, - pub xCachesize: ::std::option::Option, - pub xPagecount: ::std::option::Option ::std::os::raw::c_int>, - pub xFetch: ::std::option::Option *mut sqlite3_pcache_page>, - pub xUnpin: ::std::option::Option, - pub xRekey: ::std::option::Option, - pub xTruncate: ::std::option::Option, - pub xDestroy: ::std::option::Option, - pub xShrink: ::std::option::Option, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + szExtra: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache_page, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, + pub xShrink: ::std::option::Option, } #[test] fn bindgen_test_layout_sqlite3_pcache_methods2() { - assert_eq!(::std::mem::size_of::() , 104usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_pcache_methods2 { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iVersion as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDestroy as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShrink) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_pcache_methods { pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option ::std::os::raw::c_int>, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option *mut sqlite3_pcache>, - pub xCachesize: ::std::option::Option, - pub xPagecount: ::std::option::Option ::std::os::raw::c_int>, - pub xFetch: ::std::option::Option *mut ::std::os::raw::c_void>, - pub xUnpin: ::std::option::Option, - pub xRekey: ::std::option::Option, - pub xTruncate: ::std::option::Option, - pub xDestroy: ::std::option::Option, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, } #[test] fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!(::std::mem::size_of::() , 88usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_pcache_methods { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_backup([u8; 0]); +pub struct sqlite3_backup { + _unused: [u8; 0], +} extern "C" { - pub fn sqlite3_backup_init(pDest: *mut sqlite3, - zDestName: *const ::std::os::raw::c_char, - pSource: *mut sqlite3, - zSourceName: *const ::std::os::raw::c_char) - -> *mut sqlite3_backup; + pub fn sqlite3_backup_init( + pDest: *mut sqlite3, + zDestName: *const ::std::os::raw::c_char, + pSource: *mut sqlite3, + zSourceName: *const ::std::os::raw::c_char, + ) -> *mut sqlite3_backup; } extern "C" { - pub fn sqlite3_backup_step(p: *mut sqlite3_backup, - nPage: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_backup_step( + p: *mut sqlite3_backup, + nPage: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_backup_finish(p: *mut sqlite3_backup) - -> ::std::os::raw::c_int; + pub fn sqlite3_backup_finish(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_backup_remaining(p: *mut sqlite3_backup) - -> ::std::os::raw::c_int; + pub fn sqlite3_backup_remaining(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_backup_pagecount(p: *mut sqlite3_backup) - -> ::std::os::raw::c_int; + pub fn sqlite3_backup_pagecount(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_unlock_notify(pBlocked: *mut sqlite3, - xNotify: - ::std::option::Option, - pNotifyArg: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_unlock_notify( + pBlocked: *mut sqlite3, + xNotify: ::std::option::Option< + unsafe extern "C" fn( + apArg: *mut *mut ::std::os::raw::c_void, + nArg: ::std::os::raw::c_int, + ), + >, + pNotifyArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_stricmp(arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_stricmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_strnicmp(arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_strnicmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_log(iErrCode: ::std::os::raw::c_int, - zFormat: *const ::std::os::raw::c_char, ...); + pub fn sqlite3_log( + iErrCode: ::std::os::raw::c_int, + zFormat: *const ::std::os::raw::c_char, + ... + ); } extern "C" { - pub fn sqlite3_wal_hook(arg1: *mut sqlite3, - arg2: - ::std::option::Option - ::std::os::raw::c_int>, - arg3: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_wal_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_wal_autocheckpoint(db: *mut sqlite3, - N: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_wal_autocheckpoint( + db: *mut sqlite3, + N: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_wal_checkpoint(db: *mut sqlite3, - zDb: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_wal_checkpoint( + db: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_wal_checkpoint_v2(db: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - eMode: ::std::os::raw::c_int, - pnLog: *mut ::std::os::raw::c_int, - pnCkpt: *mut ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_wal_checkpoint_v2( + db: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + eMode: ::std::os::raw::c_int, + pnLog: *mut ::std::os::raw::c_int, + pnCkpt: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_vtab_config(arg1: *mut sqlite3, - op: ::std::os::raw::c_int, ...) - -> ::std::os::raw::c_int; + pub fn sqlite3_vtab_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) - -> ::std::os::raw::c_int; + pub fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_rtree_geometry_callback( + db: *mut sqlite3, + zGeom: *const ::std::os::raw::c_char, + xGeom: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_rtree_geometry, + n: ::std::os::raw::c_int, + a: *mut f64, + pRes: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pContext: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_rtree_geometry { pub pContext: *mut ::std::os::raw::c_void, pub nParam: ::std::os::raw::c_int, pub aParam: *mut f64, pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, + pub xDelUser: ::std::option::Option, } #[test] fn bindgen_test_layout_sqlite3_rtree_geometry() { - assert_eq!(::std::mem::size_of::() , 40usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_rtree_geometry { - fn clone(&self) -> Self { *self } -} -extern "C" { - pub fn sqlite3_rtree_geometry_callback(db: *mut sqlite3, - zGeom: - *const ::std::os::raw::c_char, - xGeom: - ::std::option::Option - ::std::os::raw::c_int>, - pContext: - *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(xDelUser) + ) + ); } +pub type __builtin_va_list = [__va_list_tag; 1usize]; #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct __va_list_tag { pub gp_offset: ::std::os::raw::c_uint, pub fp_offset: ::std::os::raw::c_uint, pub overflow_arg_area: *mut ::std::os::raw::c_void, pub reg_save_area: *mut ::std::os::raw::c_void, } -impl Clone for __va_list_tag { - fn clone(&self) -> Self { *self } +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); } -pub type __builtin_va_list = [__va_list_tag; 1usize]; - pub const SQLITE_DETERMINISTIC: i32 = 2048; diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7-ext-embed.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7-ext-embed.rs new file mode 100644 index 000000000..d47b88b83 --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7-ext-embed.rs @@ -0,0 +1,7831 @@ +/* automatically generated by rust-bindgen */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &'static [u8; 6usize] = b"3.7.7\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3007007; +pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = + b"2011-06-23 19:49:22 4374b7e83ea0a3fbc3691f9c0c936272862f32f2\0"; +pub const SQLITE_OK: i32 = 0; +pub const SQLITE_ERROR: i32 = 1; +pub const SQLITE_INTERNAL: i32 = 2; +pub const SQLITE_PERM: i32 = 3; +pub const SQLITE_ABORT: i32 = 4; +pub const SQLITE_BUSY: i32 = 5; +pub const SQLITE_LOCKED: i32 = 6; +pub const SQLITE_NOMEM: i32 = 7; +pub const SQLITE_READONLY: i32 = 8; +pub const SQLITE_INTERRUPT: i32 = 9; +pub const SQLITE_IOERR: i32 = 10; +pub const SQLITE_CORRUPT: i32 = 11; +pub const SQLITE_NOTFOUND: i32 = 12; +pub const SQLITE_FULL: i32 = 13; +pub const SQLITE_CANTOPEN: i32 = 14; +pub const SQLITE_PROTOCOL: i32 = 15; +pub const SQLITE_EMPTY: i32 = 16; +pub const SQLITE_SCHEMA: i32 = 17; +pub const SQLITE_TOOBIG: i32 = 18; +pub const SQLITE_CONSTRAINT: i32 = 19; +pub const SQLITE_MISMATCH: i32 = 20; +pub const SQLITE_MISUSE: i32 = 21; +pub const SQLITE_NOLFS: i32 = 22; +pub const SQLITE_AUTH: i32 = 23; +pub const SQLITE_FORMAT: i32 = 24; +pub const SQLITE_RANGE: i32 = 25; +pub const SQLITE_NOTADB: i32 = 26; +pub const SQLITE_ROW: i32 = 100; +pub const SQLITE_DONE: i32 = 101; +pub const SQLITE_IOERR_READ: i32 = 266; +pub const SQLITE_IOERR_SHORT_READ: i32 = 522; +pub const SQLITE_IOERR_WRITE: i32 = 778; +pub const SQLITE_IOERR_FSYNC: i32 = 1034; +pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; +pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; +pub const SQLITE_IOERR_FSTAT: i32 = 1802; +pub const SQLITE_IOERR_UNLOCK: i32 = 2058; +pub const SQLITE_IOERR_RDLOCK: i32 = 2314; +pub const SQLITE_IOERR_DELETE: i32 = 2570; +pub const SQLITE_IOERR_BLOCKED: i32 = 2826; +pub const SQLITE_IOERR_NOMEM: i32 = 3082; +pub const SQLITE_IOERR_ACCESS: i32 = 3338; +pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; +pub const SQLITE_IOERR_LOCK: i32 = 3850; +pub const SQLITE_IOERR_CLOSE: i32 = 4106; +pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; +pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; +pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; +pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; +pub const SQLITE_IOERR_SHMMAP: i32 = 5386; +pub const SQLITE_IOERR_SEEK: i32 = 5642; +pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; +pub const SQLITE_BUSY_RECOVERY: i32 = 261; +pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; +pub const SQLITE_CORRUPT_VTAB: i32 = 267; +pub const SQLITE_READONLY_RECOVERY: i32 = 264; +pub const SQLITE_READONLY_CANTLOCK: i32 = 520; +pub const SQLITE_OPEN_READONLY: i32 = 1; +pub const SQLITE_OPEN_READWRITE: i32 = 2; +pub const SQLITE_OPEN_CREATE: i32 = 4; +pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; +pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; +pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; +pub const SQLITE_OPEN_URI: i32 = 64; +pub const SQLITE_OPEN_MAIN_DB: i32 = 256; +pub const SQLITE_OPEN_TEMP_DB: i32 = 512; +pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; +pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; +pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; +pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; +pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; +pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; +pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; +pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; +pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; +pub const SQLITE_OPEN_WAL: i32 = 524288; +pub const SQLITE_IOCAP_ATOMIC: i32 = 1; +pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; +pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; +pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; +pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; +pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; +pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; +pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; +pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; +pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; +pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; +pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; +pub const SQLITE_LOCK_NONE: i32 = 0; +pub const SQLITE_LOCK_SHARED: i32 = 1; +pub const SQLITE_LOCK_RESERVED: i32 = 2; +pub const SQLITE_LOCK_PENDING: i32 = 3; +pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; +pub const SQLITE_SYNC_NORMAL: i32 = 2; +pub const SQLITE_SYNC_FULL: i32 = 3; +pub const SQLITE_SYNC_DATAONLY: i32 = 16; +pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; +pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_LAST_ERRNO: i32 = 4; +pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; +pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; +pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; +pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; +pub const SQLITE_ACCESS_EXISTS: i32 = 0; +pub const SQLITE_ACCESS_READWRITE: i32 = 1; +pub const SQLITE_ACCESS_READ: i32 = 2; +pub const SQLITE_SHM_UNLOCK: i32 = 1; +pub const SQLITE_SHM_LOCK: i32 = 2; +pub const SQLITE_SHM_SHARED: i32 = 4; +pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; +pub const SQLITE_SHM_NLOCK: i32 = 8; +pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; +pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; +pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; +pub const SQLITE_CONFIG_MALLOC: i32 = 4; +pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; +pub const SQLITE_CONFIG_SCRATCH: i32 = 6; +pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; +pub const SQLITE_CONFIG_HEAP: i32 = 8; +pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; +pub const SQLITE_CONFIG_MUTEX: i32 = 10; +pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; +pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; +pub const SQLITE_CONFIG_PCACHE: i32 = 14; +pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; +pub const SQLITE_CONFIG_LOG: i32 = 16; +pub const SQLITE_CONFIG_URI: i32 = 17; +pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; +pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; +pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; +pub const SQLITE_DENY: i32 = 1; +pub const SQLITE_IGNORE: i32 = 2; +pub const SQLITE_CREATE_INDEX: i32 = 1; +pub const SQLITE_CREATE_TABLE: i32 = 2; +pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; +pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; +pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; +pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; +pub const SQLITE_CREATE_TRIGGER: i32 = 7; +pub const SQLITE_CREATE_VIEW: i32 = 8; +pub const SQLITE_DELETE: i32 = 9; +pub const SQLITE_DROP_INDEX: i32 = 10; +pub const SQLITE_DROP_TABLE: i32 = 11; +pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; +pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; +pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; +pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; +pub const SQLITE_DROP_TRIGGER: i32 = 16; +pub const SQLITE_DROP_VIEW: i32 = 17; +pub const SQLITE_INSERT: i32 = 18; +pub const SQLITE_PRAGMA: i32 = 19; +pub const SQLITE_READ: i32 = 20; +pub const SQLITE_SELECT: i32 = 21; +pub const SQLITE_TRANSACTION: i32 = 22; +pub const SQLITE_UPDATE: i32 = 23; +pub const SQLITE_ATTACH: i32 = 24; +pub const SQLITE_DETACH: i32 = 25; +pub const SQLITE_ALTER_TABLE: i32 = 26; +pub const SQLITE_REINDEX: i32 = 27; +pub const SQLITE_ANALYZE: i32 = 28; +pub const SQLITE_CREATE_VTABLE: i32 = 29; +pub const SQLITE_DROP_VTABLE: i32 = 30; +pub const SQLITE_FUNCTION: i32 = 31; +pub const SQLITE_SAVEPOINT: i32 = 32; +pub const SQLITE_COPY: i32 = 0; +pub const SQLITE_LIMIT_LENGTH: i32 = 0; +pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; +pub const SQLITE_LIMIT_COLUMN: i32 = 2; +pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; +pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; +pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; +pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; +pub const SQLITE_LIMIT_ATTACHED: i32 = 7; +pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; +pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; +pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; +pub const SQLITE_INTEGER: i32 = 1; +pub const SQLITE_FLOAT: i32 = 2; +pub const SQLITE_BLOB: i32 = 4; +pub const SQLITE_NULL: i32 = 5; +pub const SQLITE_TEXT: i32 = 3; +pub const SQLITE3_TEXT: i32 = 3; +pub const SQLITE_UTF8: i32 = 1; +pub const SQLITE_UTF16LE: i32 = 2; +pub const SQLITE_UTF16BE: i32 = 3; +pub const SQLITE_UTF16: i32 = 4; +pub const SQLITE_ANY: i32 = 5; +pub const SQLITE_UTF16_ALIGNED: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; +pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; +pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; +pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; +pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; +pub const SQLITE_MUTEX_FAST: i32 = 0; +pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; +pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; +pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; +pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; +pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; +pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; +pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; +pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; +pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; +pub const SQLITE_TESTCTRL_FIRST: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; +pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; +pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; +pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; +pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; +pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; +pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; +pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; +pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; +pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; +pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; +pub const SQLITE_TESTCTRL_PGHDRSZ: i32 = 17; +pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 18; +pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 19; +pub const SQLITE_TESTCTRL_LAST: i32 = 19; +pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; +pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; +pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; +pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; +pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; +pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; +pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; +pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; +pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; +pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; +pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; +pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; +pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; +pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; +pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; +pub const SQLITE_DBSTATUS_MAX: i32 = 6; +pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; +pub const SQLITE_STMTSTATUS_SORT: i32 = 2; +pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; +pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; +pub const SQLITE_CHECKPOINT_FULL: i32 = 1; +pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; +pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; +pub const SQLITE_ROLLBACK: i32 = 1; +pub const SQLITE_FAIL: i32 = 3; +pub const SQLITE_REPLACE: i32 = 5; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; +extern "C" { + #[link_name = "\u{1}sqlite3_version"] + pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3 { + _unused: [u8; 0], +} +pub type sqlite_int64 = ::std::os::raw::c_longlong; +pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; +pub type sqlite3_int64 = sqlite_int64; +pub type sqlite3_uint64 = sqlite_uint64; +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_file { + pub pMethods: *const sqlite3_io_methods, +} +#[test] +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xShmMap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iPg: ::std::os::raw::c_int, + pgsz: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xShmLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + offset: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xShmBarrier: ::std::option::Option, + pub xShmUnmap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + deleteFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 136usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmMap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmBarrier) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmUnmap) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +pub type sqlite3_syscall_ptr = ::std::option::Option; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vfs { + pub iVersion: ::std::os::raw::c_int, + pub szOsFile: ::std::os::raw::c_int, + pub mxPathname: ::std::os::raw::c_int, + pub pNext: *mut sqlite3_vfs, + pub zName: *const ::std::os::raw::c_char, + pub pAppData: *mut ::std::os::raw::c_void, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTimeInt64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xSetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: sqlite3_syscall_ptr, + ) -> ::std::os::raw::c_int, + >, + pub xGetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> sqlite3_syscall_ptr, + >, + pub xNextSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_vfs() { + assert_eq!( + ::std::mem::size_of::(), + 168usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTimeInt64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xNextSystemCall) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mem_methods { + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub pAppData: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_mem_methods() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_stmt { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Mem { + _unused: [u8; 0], +} +pub type sqlite3_value = Mem; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_context { + _unused: [u8; 0], +} +pub type sqlite3_destructor_type = + ::std::option::Option; +extern "C" { + #[link_name = "\u{1}sqlite3_temp_directory"] + pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSavepoint: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRelease: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRollbackTo: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 184usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSavepoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRelease) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollbackTo) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info { + pub nConstraint: ::std::os::raw::c_int, + pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, + pub nOrderBy: ::std::os::raw::c_int, + pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, + pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, + pub idxNum: ::std::os::raw::c_int, + pub idxStr: *mut ::std::os::raw::c_char, + pub needToFreeIdxStr: ::std::os::raw::c_int, + pub orderByConsumed: ::std::os::raw::c_int, + pub estimatedCost: f64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint { + pub iColumn: ::std::os::raw::c_int, + pub op: ::std::os::raw::c_uchar, + pub usable: ::std::os::raw::c_uchar, + pub iTermOffset: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_orderby { + pub iColumn: ::std::os::raw::c_int, + pub desc: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint_usage { + pub argvIndex: ::std::os::raw::c_int, + pub omit: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); +} +#[test] +fn bindgen_test_layout_sqlite3_index_info() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_blob { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex_methods { + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_mutex_methods() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods { + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_backup { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_geometry { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut f64, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_geometry() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(xDelUser) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_api_routines { + pub aggregate_context: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub aggregate_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, + >, + pub bind_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_double: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int, + >, + pub bind_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, + ) -> ::std::os::raw::c_int, + >, + pub bind_null: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub bind_parameter_index: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub bind_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub busy_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub busy_timeout: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub changes: + ::std::option::Option ::std::os::raw::c_int>, + pub close: + ::std::option::Option ::std::os::raw::c_int>, + pub collation_needed: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub collation_needed16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub column_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_bytes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_bytes16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub column_database_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_database_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_decltype: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_decltype16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_double: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, + >, + pub column_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_int64: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, + >, + pub column_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_origin_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_origin_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_table_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_table_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar, + >, + pub column_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_type: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value, + >, + pub commit_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub complete: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub complete16: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub create_collation: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_collation16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_function16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_module: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub data_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub db_handle: + ::std::option::Option *mut sqlite3>, + pub declare_vtab: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub enable_shared_cache: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub errmsg: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, + >, + pub errmsg16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, + >, + pub exec: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub expired: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub finalize: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub free: ::std::option::Option, + pub free_table: + ::std::option::Option, + pub get_autocommit: + ::std::option::Option ::std::os::raw::c_int>, + pub get_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub get_table: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub global_recover: ::std::option::Option ::std::os::raw::c_int>, + pub interruptx: ::std::option::Option, + pub last_insert_rowid: + ::std::option::Option sqlite_int64>, + pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, + pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, + pub malloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub mprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub open16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub prepare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub profile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub progress_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ), + >, + pub realloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub result_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_double: + ::std::option::Option, + pub result_error: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_error16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_int64: + ::std::option::Option, + pub result_null: ::std::option::Option, + pub result_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16be: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16le: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_value: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), + >, + pub rollback_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub set_authorizer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub set_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, + ), + >, + pub snprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub step: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub table_column_metadata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub thread_cleanup: ::std::option::Option, + pub total_changes: + ::std::option::Option ::std::os::raw::c_int>, + pub trace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub transfer_bindings: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int, + >, + pub update_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub user_data: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, + >, + pub value_blob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_bytes16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_double: ::std::option::Option f64>, + pub value_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_int64: + ::std::option::Option sqlite_int64>, + pub value_numeric_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_text: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, + >, + pub value_text16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16be: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16le: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub vmprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub overload_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub prepare_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub clear_bindings: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub create_module_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_close: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int, + >, + pub blob_read: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_write: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub create_collation_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub file_control: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub memory_highwater: + ::std::option::Option sqlite3_int64>, + pub memory_used: ::std::option::Option sqlite3_int64>, + pub mutex_alloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub mutex_enter: ::std::option::Option, + pub mutex_free: ::std::option::Option, + pub mutex_leave: ::std::option::Option, + pub mutex_try: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub open_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub release_memory: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub result_error_nomem: ::std::option::Option, + pub result_error_toobig: + ::std::option::Option, + pub sleep: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub soft_heap_limit: ::std::option::Option, + pub vfs_find: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, + >, + pub vfs_register: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub vfs_unregister: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, + >, + pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, + pub result_zeroblob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_error_code: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub test_control: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, + >, + pub randomness: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), + >, + pub context_db_handle: + ::std::option::Option *mut sqlite3>, + pub extended_result_codes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub limit: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub next_stmt: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, + >, + pub sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, + >, + pub status: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub backup_finish: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_init: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, + ) -> *mut sqlite3_backup, + >, + pub backup_pagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_remaining: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_step: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub compileoption_get: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, + >, + pub compileoption_used: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub create_function_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub db_config: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int, + >, + pub db_mutex: + ::std::option::Option *mut sqlite3_mutex>, + pub db_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub extended_errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub log: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char, ...), + >, + pub soft_heap_limit64: + ::std::option::Option sqlite3_int64>, + pub sourceid: ::std::option::Option *const ::std::os::raw::c_char>, + pub stmt_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub strnicmp: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub unlock_notify: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub wal_autocheckpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub wal_checkpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub wal_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_api_routines() { + assert_eq!( + ::std::mem::size_of::(), + 1408usize, + concat!("Size of: ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_context as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_context) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_count as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_double as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_count as *const _ + as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_index as *const _ + as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_index) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_name as *const _ + as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text16 as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_handler as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_handler) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_timeout as *const _ as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_timeout) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed as *const _ as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_blob as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes as *const _ as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize + }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_count as *const _ as usize + }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name as *const _ + as usize + }, + 184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name16 as *const _ + as usize + }, + 192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype as *const _ as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize + }, + 208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_double as *const _ as usize + }, + 216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, + 224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_int64 as *const _ as usize + }, + 232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name as *const _ as usize + }, + 240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name16 as *const _ as usize + }, + 248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name as *const _ as usize + }, + 256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name16 as *const _ + as usize + }, + 264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name as *const _ as usize + }, + 272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name16 as *const _ + as usize + }, + 280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text as *const _ as usize + }, + 288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text16 as *const _ as usize + }, + 296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_type as *const _ as usize + }, + 304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_type) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_value as *const _ as usize + }, + 312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).commit_hook as *const _ as usize + }, + 320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(commit_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, + 328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, + 336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation as *const _ as usize + }, + 344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation16 as *const _ as usize + }, + 352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function as *const _ as usize + }, + 360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function16 as *const _ as usize + }, + 368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module as *const _ as usize + }, + 376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, + 384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(data_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, + 392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).declare_vtab as *const _ as usize + }, + 400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(declare_vtab) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).enable_shared_cache as *const _ + as usize + }, + 408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(enable_shared_cache) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, + 416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, + 424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, + 432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, + 440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(exec) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, + 448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(expired) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, + 456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(finalize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, + 464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, + 472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_autocommit as *const _ as usize + }, + 480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_autocommit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_auxdata as *const _ as usize + }, + 488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, + 496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).global_recover as *const _ as usize + }, + 504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(global_recover) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, + 512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(interruptx) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize + }, + 520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(last_insert_rowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, + 528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).libversion_number as *const _ as usize + }, + 536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion_number) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, + 544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, + 552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, + 560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, + 568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, + 576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, + 584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, + 592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(profile) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).progress_handler as *const _ as usize + }, + 600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(progress_handler) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, + 608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, + 616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob as *const _ as usize + }, + 624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_double as *const _ as usize + }, + 632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_double) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error as *const _ as usize + }, + 640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error16 as *const _ as usize + }, + 648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, + 656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_int64 as *const _ as usize + }, + 664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_null as *const _ as usize + }, + 672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text as *const _ as usize + }, + 680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16 as *const _ as usize + }, + 688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16be as *const _ as usize + }, + 696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16le as *const _ as usize + }, + 704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16le) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_value as *const _ as usize + }, + 712usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rollback_hook as *const _ as usize + }, + 720usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(rollback_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_authorizer as *const _ as usize + }, + 728usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_authorizer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_auxdata as *const _ as usize + }, + 736usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).snprintf as *const _ as usize }, + 744usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(snprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, + 752usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).table_column_metadata as *const _ + as usize + }, + 760usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(table_column_metadata) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize + }, + 768usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(thread_cleanup) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).total_changes as *const _ as usize + }, + 776usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(total_changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, + 784usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(trace) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize + }, + 792usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(transfer_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).update_hook as *const _ as usize + }, + 800usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(update_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, + 808usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(user_data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, + 816usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes as *const _ as usize + }, + 824usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize + }, + 832usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_double as *const _ as usize + }, + 840usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, + 848usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_int64 as *const _ as usize + }, + 856usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize + }, + 864usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_numeric_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, + 872usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16 as *const _ as usize + }, + 880usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16be as *const _ as usize + }, + 888usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16le as *const _ as usize + }, + 896usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16le) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, + 904usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, + 912usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vmprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).overload_function as *const _ as usize + }, + 920usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(overload_function) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, + 928usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize + }, + 936usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).clear_bindings as *const _ as usize + }, + 944usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(clear_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize + }, + 952usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize + }, + 960usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, + 968usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_bytes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, + 976usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_close) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, + 984usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, + 992usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_read) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, + 1000usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_write) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation_v2 as *const _ + as usize + }, + 1008usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).file_control as *const _ as usize + }, + 1016usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(file_control) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_highwater as *const _ as usize + }, + 1024usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_highwater) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_used as *const _ as usize + }, + 1032usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize + }, + 1040usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_alloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_enter as *const _ as usize + }, + 1048usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_enter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, + 1056usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_leave as *const _ as usize + }, + 1064usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_leave) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, + 1072usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_try) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, + 1080usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).release_memory as *const _ as usize + }, + 1088usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(release_memory) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize + }, + 1096usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_nomem) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_toobig as *const _ + as usize + }, + 1104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_toobig) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, + 1112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sleep) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize + }, + 1120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, + 1128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_find) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_register as *const _ as usize + }, + 1136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_register) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize + }, + 1144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_unregister) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize + }, + 1152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xthreadsafe) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize + }, + 1160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_code as *const _ as usize + }, + 1168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_code) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).test_control as *const _ as usize + }, + 1176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(test_control) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, + 1184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(randomness) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).context_db_handle as *const _ as usize + }, + 1192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(context_db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_result_codes as *const _ + as usize + }, + 1200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_result_codes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, + 1208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, + 1216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(next_stmt) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, + 1224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sql) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, + 1232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_finish as *const _ as usize + }, + 1240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_finish) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_init as *const _ as usize + }, + 1248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_init) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_pagecount as *const _ as usize + }, + 1256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_pagecount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_remaining as *const _ as usize + }, + 1264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_remaining) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_step as *const _ as usize + }, + 1272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_get as *const _ as usize + }, + 1280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_get) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_used as *const _ as usize + }, + 1288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function_v2 as *const _ as usize + }, + 1296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function_v2) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_config as *const _ as usize }, + 1304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_config) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_mutex as *const _ as usize }, + 1312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_mutex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_status as *const _ as usize }, + 1320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_errcode as *const _ as usize + }, + 1328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).log as *const _ as usize }, + 1336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(log) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit64 as *const _ as usize + }, + 1344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sourceid as *const _ as usize }, + 1352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sourceid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stmt_status as *const _ as usize + }, + 1360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_status) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strnicmp as *const _ as usize }, + 1368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strnicmp) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).unlock_notify as *const _ as usize + }, + 1376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(unlock_notify) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_autocheckpoint as *const _ as usize + }, + 1384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_autocheckpoint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_checkpoint as *const _ as usize + }, + 1392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_checkpoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).wal_hook as *const _ as usize }, + 1400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_hook) + ) + ); +} +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} + +// bindings were built with loadable_extension_embedded: +// define sqlite3_api as an extern since this code will be embedded +// within a loadable extension that defines and exports this itself +extern "C" { + #[no_mangle] + pub static mut sqlite3_api: *mut sqlite3_api_routines; +} + +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) + +pub unsafe fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_context.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_context", + " function" + )))(arg1, nBytes) +} + +pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_double", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_null", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_index.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_index", + " function" + )))(arg1, zName) +} + +pub unsafe fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_value", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_handler", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_timeout.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_timeout", + " function" + )))(arg1, ms) +} + +pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_blob", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype", + " function" + )))(arg1, i) +} + +pub unsafe fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_double", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int64", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_type", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_value", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).commit_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "commit_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete16", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_create_collation( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_collation16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_function( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_function16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function16", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_module( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).data_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "data_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).declare_vtab.expect(stringify!( + "sqlite3_api contains null pointer for ", + "declare_vtab", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).enable_shared_cache.expect(stringify!( + "sqlite3_api contains null pointer for ", + "enable_shared_cache", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errcode", + " function" + )))(db) +} + +pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_exec( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).exec.expect(stringify!( + "sqlite3_api contains null pointer for ", + "exec", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).expired.expect(stringify!( + "sqlite3_api contains null pointer for ", + "expired", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).finalize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "finalize", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free_table", + " function" + )))(result) +} + +pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_autocommit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_autocommit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_auxdata", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_get_table( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_table", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).global_recover.expect(stringify!( + "sqlite3_api contains null pointer for ", + "global_recover", + " function" + )))() +} + +pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).interruptx.expect(stringify!( + "sqlite3_api contains null pointer for ", + "interruptx", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).last_insert_rowid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "last_insert_rowid", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion", + " function" + )))() +} + +pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion_number.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion_number", + " function" + )))() +} + +pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mprintf( + arg1: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mprintf", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_open( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_open16( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_prepare( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_profile( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).profile.expect(stringify!( + "sqlite3_api contains null pointer for ", + "profile", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).progress_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "progress_handler", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_double", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_null", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16be", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16le", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_value", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).rollback_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "rollback_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_authorizer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_authorizer", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_auxdata", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_snprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).snprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "snprintf", + " function" + )))(arg1, arg2, arg3, vararg1) +} + +pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "step", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_table_column_metadata( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).table_column_metadata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "table_column_metadata", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) +} + +pub unsafe fn sqlite3_thread_cleanup() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).thread_cleanup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "thread_cleanup", + " function" + )))() +} + +pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).total_changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "total_changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).trace.expect(stringify!( + "sqlite3_api contains null pointer for ", + "trace", + " function" + )))(arg1, xTrace, arg2) +} + +pub unsafe fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).transfer_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "transfer_bindings", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).update_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "update_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).user_data.expect(stringify!( + "sqlite3_api contains null pointer for ", + "user_data", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_blob", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_double", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_numeric_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_numeric_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16be", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16le", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vmprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vmprintf", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).overload_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "overload_function", + " function" + )))(arg1, zFuncName, nArg) +} + +pub unsafe fn sqlite3_prepare_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).clear_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "clear_bindings", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_module_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module_v2", + " function" + )))(arg1, arg2, arg3, arg4, xDestroy) +} + +pub unsafe fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_open( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_open", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) +} + +pub unsafe fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_read.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_read", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_write.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_write", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_file_control( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).file_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "file_control", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_highwater.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_highwater", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_used", + " function" + )))() +} + +pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_alloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_alloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_enter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_enter", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_leave.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_leave", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_try.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_try", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_open_v2( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open_v2", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_nomem.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_nomem", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_toobig.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_toobig", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sleep.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sleep", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_find.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_find", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_register.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_register", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_unregister.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_unregister", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xthreadsafe.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xthreadsafe", + " function" + )))() +} + +pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_code.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_code", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_test_control( + arg1: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).test_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "test_control", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).randomness.expect(stringify!( + "sqlite3_api contains null pointer for ", + "randomness", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).context_db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "context_db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_result_codes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_result_codes", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_limit( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "limit", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).next_stmt.expect(stringify!( + "sqlite3_api contains null pointer for ", + "next_stmt", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_status( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_finish.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_finish", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_init( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, +) -> *mut sqlite3_backup { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_init.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_init", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_pagecount.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_pagecount", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_remaining.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_remaining", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_step( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_step", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_compileoption_get( + arg1: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_get.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_get", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_compileoption_used( + arg1: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_used", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_function_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal, xDestroy) +} + +pub unsafe fn sqlite3_db_config( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, + vararg2: &mut i32, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_config", + " function" + )))(arg1, arg2, vararg1, vararg2) +} + +pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_mutex.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_mutex", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_db_status( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_status", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_errcode", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_log( + arg1: ::std::os::raw::c_int, + arg2: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).log.expect(stringify!( + "sqlite3_api contains null pointer for ", + "log", + " function" + )))(arg1, arg2, vararg1) +} + +pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sourceid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sourceid", + " function" + )))() +} + +pub unsafe fn sqlite3_stmt_status( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_status", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_strnicmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strnicmp.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strnicmp", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_unlock_notify( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int), + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).unlock_notify.expect(stringify!( + "sqlite3_api contains null pointer for ", + "unlock_notify", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_wal_autocheckpoint( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_autocheckpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_checkpoint( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_checkpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_checkpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub const SQLITE_DETERMINISTIC: i32 = 2048; diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7-ext.rs new file mode 100644 index 000000000..2e44d421e --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7-ext.rs @@ -0,0 +1,7829 @@ +/* automatically generated by rust-bindgen */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &'static [u8; 6usize] = b"3.7.7\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3007007; +pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = + b"2011-06-23 19:49:22 4374b7e83ea0a3fbc3691f9c0c936272862f32f2\0"; +pub const SQLITE_OK: i32 = 0; +pub const SQLITE_ERROR: i32 = 1; +pub const SQLITE_INTERNAL: i32 = 2; +pub const SQLITE_PERM: i32 = 3; +pub const SQLITE_ABORT: i32 = 4; +pub const SQLITE_BUSY: i32 = 5; +pub const SQLITE_LOCKED: i32 = 6; +pub const SQLITE_NOMEM: i32 = 7; +pub const SQLITE_READONLY: i32 = 8; +pub const SQLITE_INTERRUPT: i32 = 9; +pub const SQLITE_IOERR: i32 = 10; +pub const SQLITE_CORRUPT: i32 = 11; +pub const SQLITE_NOTFOUND: i32 = 12; +pub const SQLITE_FULL: i32 = 13; +pub const SQLITE_CANTOPEN: i32 = 14; +pub const SQLITE_PROTOCOL: i32 = 15; +pub const SQLITE_EMPTY: i32 = 16; +pub const SQLITE_SCHEMA: i32 = 17; +pub const SQLITE_TOOBIG: i32 = 18; +pub const SQLITE_CONSTRAINT: i32 = 19; +pub const SQLITE_MISMATCH: i32 = 20; +pub const SQLITE_MISUSE: i32 = 21; +pub const SQLITE_NOLFS: i32 = 22; +pub const SQLITE_AUTH: i32 = 23; +pub const SQLITE_FORMAT: i32 = 24; +pub const SQLITE_RANGE: i32 = 25; +pub const SQLITE_NOTADB: i32 = 26; +pub const SQLITE_ROW: i32 = 100; +pub const SQLITE_DONE: i32 = 101; +pub const SQLITE_IOERR_READ: i32 = 266; +pub const SQLITE_IOERR_SHORT_READ: i32 = 522; +pub const SQLITE_IOERR_WRITE: i32 = 778; +pub const SQLITE_IOERR_FSYNC: i32 = 1034; +pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; +pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; +pub const SQLITE_IOERR_FSTAT: i32 = 1802; +pub const SQLITE_IOERR_UNLOCK: i32 = 2058; +pub const SQLITE_IOERR_RDLOCK: i32 = 2314; +pub const SQLITE_IOERR_DELETE: i32 = 2570; +pub const SQLITE_IOERR_BLOCKED: i32 = 2826; +pub const SQLITE_IOERR_NOMEM: i32 = 3082; +pub const SQLITE_IOERR_ACCESS: i32 = 3338; +pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; +pub const SQLITE_IOERR_LOCK: i32 = 3850; +pub const SQLITE_IOERR_CLOSE: i32 = 4106; +pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; +pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; +pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; +pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; +pub const SQLITE_IOERR_SHMMAP: i32 = 5386; +pub const SQLITE_IOERR_SEEK: i32 = 5642; +pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; +pub const SQLITE_BUSY_RECOVERY: i32 = 261; +pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; +pub const SQLITE_CORRUPT_VTAB: i32 = 267; +pub const SQLITE_READONLY_RECOVERY: i32 = 264; +pub const SQLITE_READONLY_CANTLOCK: i32 = 520; +pub const SQLITE_OPEN_READONLY: i32 = 1; +pub const SQLITE_OPEN_READWRITE: i32 = 2; +pub const SQLITE_OPEN_CREATE: i32 = 4; +pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; +pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; +pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; +pub const SQLITE_OPEN_URI: i32 = 64; +pub const SQLITE_OPEN_MAIN_DB: i32 = 256; +pub const SQLITE_OPEN_TEMP_DB: i32 = 512; +pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; +pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; +pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; +pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; +pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; +pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; +pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; +pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; +pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; +pub const SQLITE_OPEN_WAL: i32 = 524288; +pub const SQLITE_IOCAP_ATOMIC: i32 = 1; +pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; +pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; +pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; +pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; +pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; +pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; +pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; +pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; +pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; +pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; +pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; +pub const SQLITE_LOCK_NONE: i32 = 0; +pub const SQLITE_LOCK_SHARED: i32 = 1; +pub const SQLITE_LOCK_RESERVED: i32 = 2; +pub const SQLITE_LOCK_PENDING: i32 = 3; +pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; +pub const SQLITE_SYNC_NORMAL: i32 = 2; +pub const SQLITE_SYNC_FULL: i32 = 3; +pub const SQLITE_SYNC_DATAONLY: i32 = 16; +pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; +pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_LAST_ERRNO: i32 = 4; +pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; +pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; +pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; +pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; +pub const SQLITE_ACCESS_EXISTS: i32 = 0; +pub const SQLITE_ACCESS_READWRITE: i32 = 1; +pub const SQLITE_ACCESS_READ: i32 = 2; +pub const SQLITE_SHM_UNLOCK: i32 = 1; +pub const SQLITE_SHM_LOCK: i32 = 2; +pub const SQLITE_SHM_SHARED: i32 = 4; +pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; +pub const SQLITE_SHM_NLOCK: i32 = 8; +pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; +pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; +pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; +pub const SQLITE_CONFIG_MALLOC: i32 = 4; +pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; +pub const SQLITE_CONFIG_SCRATCH: i32 = 6; +pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; +pub const SQLITE_CONFIG_HEAP: i32 = 8; +pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; +pub const SQLITE_CONFIG_MUTEX: i32 = 10; +pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; +pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; +pub const SQLITE_CONFIG_PCACHE: i32 = 14; +pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; +pub const SQLITE_CONFIG_LOG: i32 = 16; +pub const SQLITE_CONFIG_URI: i32 = 17; +pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; +pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; +pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; +pub const SQLITE_DENY: i32 = 1; +pub const SQLITE_IGNORE: i32 = 2; +pub const SQLITE_CREATE_INDEX: i32 = 1; +pub const SQLITE_CREATE_TABLE: i32 = 2; +pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; +pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; +pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; +pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; +pub const SQLITE_CREATE_TRIGGER: i32 = 7; +pub const SQLITE_CREATE_VIEW: i32 = 8; +pub const SQLITE_DELETE: i32 = 9; +pub const SQLITE_DROP_INDEX: i32 = 10; +pub const SQLITE_DROP_TABLE: i32 = 11; +pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; +pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; +pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; +pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; +pub const SQLITE_DROP_TRIGGER: i32 = 16; +pub const SQLITE_DROP_VIEW: i32 = 17; +pub const SQLITE_INSERT: i32 = 18; +pub const SQLITE_PRAGMA: i32 = 19; +pub const SQLITE_READ: i32 = 20; +pub const SQLITE_SELECT: i32 = 21; +pub const SQLITE_TRANSACTION: i32 = 22; +pub const SQLITE_UPDATE: i32 = 23; +pub const SQLITE_ATTACH: i32 = 24; +pub const SQLITE_DETACH: i32 = 25; +pub const SQLITE_ALTER_TABLE: i32 = 26; +pub const SQLITE_REINDEX: i32 = 27; +pub const SQLITE_ANALYZE: i32 = 28; +pub const SQLITE_CREATE_VTABLE: i32 = 29; +pub const SQLITE_DROP_VTABLE: i32 = 30; +pub const SQLITE_FUNCTION: i32 = 31; +pub const SQLITE_SAVEPOINT: i32 = 32; +pub const SQLITE_COPY: i32 = 0; +pub const SQLITE_LIMIT_LENGTH: i32 = 0; +pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; +pub const SQLITE_LIMIT_COLUMN: i32 = 2; +pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; +pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; +pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; +pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; +pub const SQLITE_LIMIT_ATTACHED: i32 = 7; +pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; +pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; +pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; +pub const SQLITE_INTEGER: i32 = 1; +pub const SQLITE_FLOAT: i32 = 2; +pub const SQLITE_BLOB: i32 = 4; +pub const SQLITE_NULL: i32 = 5; +pub const SQLITE_TEXT: i32 = 3; +pub const SQLITE3_TEXT: i32 = 3; +pub const SQLITE_UTF8: i32 = 1; +pub const SQLITE_UTF16LE: i32 = 2; +pub const SQLITE_UTF16BE: i32 = 3; +pub const SQLITE_UTF16: i32 = 4; +pub const SQLITE_ANY: i32 = 5; +pub const SQLITE_UTF16_ALIGNED: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; +pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; +pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; +pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; +pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; +pub const SQLITE_MUTEX_FAST: i32 = 0; +pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; +pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; +pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; +pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; +pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; +pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; +pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; +pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; +pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; +pub const SQLITE_TESTCTRL_FIRST: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; +pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; +pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; +pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; +pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; +pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; +pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; +pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; +pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; +pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; +pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; +pub const SQLITE_TESTCTRL_PGHDRSZ: i32 = 17; +pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 18; +pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 19; +pub const SQLITE_TESTCTRL_LAST: i32 = 19; +pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; +pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; +pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; +pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; +pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; +pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; +pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; +pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; +pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; +pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; +pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; +pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; +pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; +pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; +pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; +pub const SQLITE_DBSTATUS_MAX: i32 = 6; +pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; +pub const SQLITE_STMTSTATUS_SORT: i32 = 2; +pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; +pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; +pub const SQLITE_CHECKPOINT_FULL: i32 = 1; +pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; +pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; +pub const SQLITE_ROLLBACK: i32 = 1; +pub const SQLITE_FAIL: i32 = 3; +pub const SQLITE_REPLACE: i32 = 5; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; +extern "C" { + #[link_name = "\u{1}sqlite3_version"] + pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3 { + _unused: [u8; 0], +} +pub type sqlite_int64 = ::std::os::raw::c_longlong; +pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; +pub type sqlite3_int64 = sqlite_int64; +pub type sqlite3_uint64 = sqlite_uint64; +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_file { + pub pMethods: *const sqlite3_io_methods, +} +#[test] +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xShmMap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iPg: ::std::os::raw::c_int, + pgsz: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xShmLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + offset: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xShmBarrier: ::std::option::Option, + pub xShmUnmap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + deleteFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 136usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmMap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmBarrier) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmUnmap) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +pub type sqlite3_syscall_ptr = ::std::option::Option; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vfs { + pub iVersion: ::std::os::raw::c_int, + pub szOsFile: ::std::os::raw::c_int, + pub mxPathname: ::std::os::raw::c_int, + pub pNext: *mut sqlite3_vfs, + pub zName: *const ::std::os::raw::c_char, + pub pAppData: *mut ::std::os::raw::c_void, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTimeInt64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xSetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: sqlite3_syscall_ptr, + ) -> ::std::os::raw::c_int, + >, + pub xGetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> sqlite3_syscall_ptr, + >, + pub xNextSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_vfs() { + assert_eq!( + ::std::mem::size_of::(), + 168usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTimeInt64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xNextSystemCall) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mem_methods { + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub pAppData: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_mem_methods() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_stmt { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Mem { + _unused: [u8; 0], +} +pub type sqlite3_value = Mem; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_context { + _unused: [u8; 0], +} +pub type sqlite3_destructor_type = + ::std::option::Option; +extern "C" { + #[link_name = "\u{1}sqlite3_temp_directory"] + pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSavepoint: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRelease: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRollbackTo: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 184usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSavepoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRelease) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollbackTo) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info { + pub nConstraint: ::std::os::raw::c_int, + pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, + pub nOrderBy: ::std::os::raw::c_int, + pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, + pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, + pub idxNum: ::std::os::raw::c_int, + pub idxStr: *mut ::std::os::raw::c_char, + pub needToFreeIdxStr: ::std::os::raw::c_int, + pub orderByConsumed: ::std::os::raw::c_int, + pub estimatedCost: f64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint { + pub iColumn: ::std::os::raw::c_int, + pub op: ::std::os::raw::c_uchar, + pub usable: ::std::os::raw::c_uchar, + pub iTermOffset: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_orderby { + pub iColumn: ::std::os::raw::c_int, + pub desc: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint_usage { + pub argvIndex: ::std::os::raw::c_int, + pub omit: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); +} +#[test] +fn bindgen_test_layout_sqlite3_index_info() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_blob { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex_methods { + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_mutex_methods() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods { + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_backup { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_geometry { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut f64, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_geometry() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(xDelUser) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_api_routines { + pub aggregate_context: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub aggregate_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, + >, + pub bind_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_double: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int, + >, + pub bind_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, + ) -> ::std::os::raw::c_int, + >, + pub bind_null: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub bind_parameter_index: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub bind_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub busy_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub busy_timeout: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub changes: + ::std::option::Option ::std::os::raw::c_int>, + pub close: + ::std::option::Option ::std::os::raw::c_int>, + pub collation_needed: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub collation_needed16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub column_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_bytes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_bytes16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub column_database_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_database_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_decltype: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_decltype16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_double: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, + >, + pub column_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_int64: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, + >, + pub column_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_origin_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_origin_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_table_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_table_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar, + >, + pub column_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_type: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value, + >, + pub commit_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub complete: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub complete16: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub create_collation: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_collation16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_function16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_module: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub data_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub db_handle: + ::std::option::Option *mut sqlite3>, + pub declare_vtab: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub enable_shared_cache: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub errmsg: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, + >, + pub errmsg16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, + >, + pub exec: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub expired: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub finalize: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub free: ::std::option::Option, + pub free_table: + ::std::option::Option, + pub get_autocommit: + ::std::option::Option ::std::os::raw::c_int>, + pub get_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub get_table: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub global_recover: ::std::option::Option ::std::os::raw::c_int>, + pub interruptx: ::std::option::Option, + pub last_insert_rowid: + ::std::option::Option sqlite_int64>, + pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, + pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, + pub malloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub mprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub open16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub prepare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub profile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub progress_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ), + >, + pub realloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub result_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_double: + ::std::option::Option, + pub result_error: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_error16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_int64: + ::std::option::Option, + pub result_null: ::std::option::Option, + pub result_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16be: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16le: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_value: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), + >, + pub rollback_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub set_authorizer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub set_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, + ), + >, + pub snprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub step: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub table_column_metadata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub thread_cleanup: ::std::option::Option, + pub total_changes: + ::std::option::Option ::std::os::raw::c_int>, + pub trace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub transfer_bindings: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int, + >, + pub update_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub user_data: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, + >, + pub value_blob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_bytes16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_double: ::std::option::Option f64>, + pub value_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_int64: + ::std::option::Option sqlite_int64>, + pub value_numeric_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_text: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, + >, + pub value_text16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16be: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16le: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub vmprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub overload_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub prepare_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub clear_bindings: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub create_module_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_close: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int, + >, + pub blob_read: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_write: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub create_collation_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub file_control: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub memory_highwater: + ::std::option::Option sqlite3_int64>, + pub memory_used: ::std::option::Option sqlite3_int64>, + pub mutex_alloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub mutex_enter: ::std::option::Option, + pub mutex_free: ::std::option::Option, + pub mutex_leave: ::std::option::Option, + pub mutex_try: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub open_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub release_memory: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub result_error_nomem: ::std::option::Option, + pub result_error_toobig: + ::std::option::Option, + pub sleep: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub soft_heap_limit: ::std::option::Option, + pub vfs_find: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, + >, + pub vfs_register: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub vfs_unregister: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, + >, + pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, + pub result_zeroblob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_error_code: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub test_control: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, + >, + pub randomness: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), + >, + pub context_db_handle: + ::std::option::Option *mut sqlite3>, + pub extended_result_codes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub limit: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub next_stmt: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, + >, + pub sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, + >, + pub status: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub backup_finish: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_init: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, + ) -> *mut sqlite3_backup, + >, + pub backup_pagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_remaining: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_step: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub compileoption_get: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, + >, + pub compileoption_used: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub create_function_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub db_config: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int, + >, + pub db_mutex: + ::std::option::Option *mut sqlite3_mutex>, + pub db_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub extended_errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub log: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char, ...), + >, + pub soft_heap_limit64: + ::std::option::Option sqlite3_int64>, + pub sourceid: ::std::option::Option *const ::std::os::raw::c_char>, + pub stmt_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub strnicmp: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub unlock_notify: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub wal_autocheckpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub wal_checkpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub wal_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_api_routines() { + assert_eq!( + ::std::mem::size_of::(), + 1408usize, + concat!("Size of: ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_context as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_context) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_count as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_double as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_count as *const _ + as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_index as *const _ + as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_index) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_name as *const _ + as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text16 as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_handler as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_handler) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_timeout as *const _ as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_timeout) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed as *const _ as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_blob as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes as *const _ as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize + }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_count as *const _ as usize + }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name as *const _ + as usize + }, + 184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name16 as *const _ + as usize + }, + 192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype as *const _ as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize + }, + 208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_double as *const _ as usize + }, + 216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, + 224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_int64 as *const _ as usize + }, + 232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name as *const _ as usize + }, + 240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name16 as *const _ as usize + }, + 248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name as *const _ as usize + }, + 256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name16 as *const _ + as usize + }, + 264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name as *const _ as usize + }, + 272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name16 as *const _ + as usize + }, + 280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text as *const _ as usize + }, + 288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text16 as *const _ as usize + }, + 296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_type as *const _ as usize + }, + 304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_type) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_value as *const _ as usize + }, + 312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).commit_hook as *const _ as usize + }, + 320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(commit_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, + 328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, + 336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation as *const _ as usize + }, + 344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation16 as *const _ as usize + }, + 352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function as *const _ as usize + }, + 360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function16 as *const _ as usize + }, + 368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module as *const _ as usize + }, + 376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, + 384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(data_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, + 392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).declare_vtab as *const _ as usize + }, + 400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(declare_vtab) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).enable_shared_cache as *const _ + as usize + }, + 408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(enable_shared_cache) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, + 416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, + 424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, + 432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, + 440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(exec) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, + 448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(expired) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, + 456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(finalize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, + 464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, + 472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_autocommit as *const _ as usize + }, + 480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_autocommit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_auxdata as *const _ as usize + }, + 488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, + 496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).global_recover as *const _ as usize + }, + 504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(global_recover) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, + 512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(interruptx) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize + }, + 520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(last_insert_rowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, + 528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).libversion_number as *const _ as usize + }, + 536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion_number) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, + 544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, + 552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, + 560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, + 568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, + 576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, + 584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, + 592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(profile) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).progress_handler as *const _ as usize + }, + 600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(progress_handler) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, + 608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, + 616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob as *const _ as usize + }, + 624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_double as *const _ as usize + }, + 632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_double) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error as *const _ as usize + }, + 640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error16 as *const _ as usize + }, + 648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, + 656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_int64 as *const _ as usize + }, + 664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_null as *const _ as usize + }, + 672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text as *const _ as usize + }, + 680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16 as *const _ as usize + }, + 688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16be as *const _ as usize + }, + 696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16le as *const _ as usize + }, + 704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16le) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_value as *const _ as usize + }, + 712usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rollback_hook as *const _ as usize + }, + 720usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(rollback_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_authorizer as *const _ as usize + }, + 728usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_authorizer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_auxdata as *const _ as usize + }, + 736usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).snprintf as *const _ as usize }, + 744usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(snprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, + 752usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).table_column_metadata as *const _ + as usize + }, + 760usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(table_column_metadata) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize + }, + 768usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(thread_cleanup) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).total_changes as *const _ as usize + }, + 776usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(total_changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, + 784usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(trace) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize + }, + 792usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(transfer_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).update_hook as *const _ as usize + }, + 800usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(update_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, + 808usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(user_data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, + 816usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes as *const _ as usize + }, + 824usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize + }, + 832usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_double as *const _ as usize + }, + 840usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, + 848usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_int64 as *const _ as usize + }, + 856usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize + }, + 864usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_numeric_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, + 872usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16 as *const _ as usize + }, + 880usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16be as *const _ as usize + }, + 888usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16le as *const _ as usize + }, + 896usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16le) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, + 904usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, + 912usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vmprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).overload_function as *const _ as usize + }, + 920usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(overload_function) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, + 928usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize + }, + 936usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).clear_bindings as *const _ as usize + }, + 944usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(clear_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize + }, + 952usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize + }, + 960usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, + 968usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_bytes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, + 976usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_close) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, + 984usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, + 992usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_read) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, + 1000usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_write) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation_v2 as *const _ + as usize + }, + 1008usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).file_control as *const _ as usize + }, + 1016usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(file_control) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_highwater as *const _ as usize + }, + 1024usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_highwater) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_used as *const _ as usize + }, + 1032usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize + }, + 1040usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_alloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_enter as *const _ as usize + }, + 1048usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_enter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, + 1056usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_leave as *const _ as usize + }, + 1064usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_leave) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, + 1072usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_try) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, + 1080usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).release_memory as *const _ as usize + }, + 1088usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(release_memory) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize + }, + 1096usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_nomem) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_toobig as *const _ + as usize + }, + 1104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_toobig) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, + 1112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sleep) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize + }, + 1120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, + 1128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_find) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_register as *const _ as usize + }, + 1136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_register) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize + }, + 1144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_unregister) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize + }, + 1152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xthreadsafe) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize + }, + 1160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_code as *const _ as usize + }, + 1168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_code) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).test_control as *const _ as usize + }, + 1176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(test_control) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, + 1184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(randomness) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).context_db_handle as *const _ as usize + }, + 1192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(context_db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_result_codes as *const _ + as usize + }, + 1200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_result_codes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, + 1208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, + 1216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(next_stmt) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, + 1224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sql) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, + 1232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_finish as *const _ as usize + }, + 1240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_finish) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_init as *const _ as usize + }, + 1248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_init) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_pagecount as *const _ as usize + }, + 1256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_pagecount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_remaining as *const _ as usize + }, + 1264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_remaining) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_step as *const _ as usize + }, + 1272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_get as *const _ as usize + }, + 1280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_get) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_used as *const _ as usize + }, + 1288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function_v2 as *const _ as usize + }, + 1296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function_v2) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_config as *const _ as usize }, + 1304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_config) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_mutex as *const _ as usize }, + 1312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_mutex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_status as *const _ as usize }, + 1320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_errcode as *const _ as usize + }, + 1328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).log as *const _ as usize }, + 1336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(log) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit64 as *const _ as usize + }, + 1344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sourceid as *const _ as usize }, + 1352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sourceid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stmt_status as *const _ as usize + }, + 1360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_status) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strnicmp as *const _ as usize }, + 1368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strnicmp) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).unlock_notify as *const _ as usize + }, + 1376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(unlock_notify) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_autocheckpoint as *const _ as usize + }, + 1384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_autocheckpoint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_checkpoint as *const _ as usize + }, + 1392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_checkpoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).wal_hook as *const _ as usize }, + 1400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_hook) + ) + ); +} +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} + +// bindings were built with (non-embedded) loadable_extension: +// we define our own sqlite_api static variable and export it +// to C +#[no_mangle] +pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_routines; + +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) + +pub unsafe fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_context.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_context", + " function" + )))(arg1, nBytes) +} + +pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_double", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_null", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_index.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_index", + " function" + )))(arg1, zName) +} + +pub unsafe fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_value", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_handler", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_timeout.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_timeout", + " function" + )))(arg1, ms) +} + +pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_blob", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype", + " function" + )))(arg1, i) +} + +pub unsafe fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_double", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int64", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_type", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_value", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).commit_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "commit_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete16", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_create_collation( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_collation16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_function( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_function16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function16", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_module( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).data_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "data_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).declare_vtab.expect(stringify!( + "sqlite3_api contains null pointer for ", + "declare_vtab", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).enable_shared_cache.expect(stringify!( + "sqlite3_api contains null pointer for ", + "enable_shared_cache", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errcode", + " function" + )))(db) +} + +pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_exec( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).exec.expect(stringify!( + "sqlite3_api contains null pointer for ", + "exec", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).expired.expect(stringify!( + "sqlite3_api contains null pointer for ", + "expired", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).finalize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "finalize", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free_table", + " function" + )))(result) +} + +pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_autocommit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_autocommit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_auxdata", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_get_table( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_table", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).global_recover.expect(stringify!( + "sqlite3_api contains null pointer for ", + "global_recover", + " function" + )))() +} + +pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).interruptx.expect(stringify!( + "sqlite3_api contains null pointer for ", + "interruptx", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).last_insert_rowid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "last_insert_rowid", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion", + " function" + )))() +} + +pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion_number.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion_number", + " function" + )))() +} + +pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mprintf( + arg1: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mprintf", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_open( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_open16( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_prepare( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_profile( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).profile.expect(stringify!( + "sqlite3_api contains null pointer for ", + "profile", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).progress_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "progress_handler", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_double", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_null", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16be", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16le", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_value", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).rollback_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "rollback_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_authorizer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_authorizer", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_auxdata", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_snprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).snprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "snprintf", + " function" + )))(arg1, arg2, arg3, vararg1) +} + +pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "step", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_table_column_metadata( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).table_column_metadata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "table_column_metadata", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) +} + +pub unsafe fn sqlite3_thread_cleanup() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).thread_cleanup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "thread_cleanup", + " function" + )))() +} + +pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).total_changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "total_changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).trace.expect(stringify!( + "sqlite3_api contains null pointer for ", + "trace", + " function" + )))(arg1, xTrace, arg2) +} + +pub unsafe fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).transfer_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "transfer_bindings", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).update_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "update_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).user_data.expect(stringify!( + "sqlite3_api contains null pointer for ", + "user_data", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_blob", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_double", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_numeric_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_numeric_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16be", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16le", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vmprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vmprintf", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).overload_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "overload_function", + " function" + )))(arg1, zFuncName, nArg) +} + +pub unsafe fn sqlite3_prepare_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).clear_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "clear_bindings", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_module_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module_v2", + " function" + )))(arg1, arg2, arg3, arg4, xDestroy) +} + +pub unsafe fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_open( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_open", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) +} + +pub unsafe fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_read.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_read", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_write.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_write", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_file_control( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).file_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "file_control", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_highwater.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_highwater", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_used", + " function" + )))() +} + +pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_alloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_alloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_enter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_enter", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_leave.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_leave", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_try.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_try", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_open_v2( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open_v2", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_nomem.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_nomem", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_toobig.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_toobig", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sleep.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sleep", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_find.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_find", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_register.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_register", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_unregister.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_unregister", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xthreadsafe.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xthreadsafe", + " function" + )))() +} + +pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_code.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_code", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_test_control( + arg1: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).test_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "test_control", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).randomness.expect(stringify!( + "sqlite3_api contains null pointer for ", + "randomness", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).context_db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "context_db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_result_codes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_result_codes", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_limit( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "limit", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).next_stmt.expect(stringify!( + "sqlite3_api contains null pointer for ", + "next_stmt", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_status( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_finish.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_finish", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_init( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, +) -> *mut sqlite3_backup { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_init.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_init", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_pagecount.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_pagecount", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_remaining.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_remaining", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_step( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_step", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_compileoption_get( + arg1: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_get.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_get", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_compileoption_used( + arg1: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_used", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_function_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal, xDestroy) +} + +pub unsafe fn sqlite3_db_config( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, + vararg2: &mut i32, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_config", + " function" + )))(arg1, arg2, vararg1, vararg2) +} + +pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_mutex.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_mutex", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_db_status( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_status", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_errcode", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_log( + arg1: ::std::os::raw::c_int, + arg2: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).log.expect(stringify!( + "sqlite3_api contains null pointer for ", + "log", + " function" + )))(arg1, arg2, vararg1) +} + +pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sourceid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sourceid", + " function" + )))() +} + +pub unsafe fn sqlite3_stmt_status( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_status", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_strnicmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strnicmp.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strnicmp", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_unlock_notify( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int), + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).unlock_notify.expect(stringify!( + "sqlite3_api contains null pointer for ", + "unlock_notify", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_wal_autocheckpoint( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_autocheckpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_checkpoint( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_checkpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_checkpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub const SQLITE_DETERMINISTIC: i32 = 2048; diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7.rs index 37bebe388..93c3eccbe 100644 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7.rs +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7.rs @@ -1,10 +1,10 @@ /* automatically generated by rust-bindgen */ pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 6usize] = b"3.7.7\x00"; +pub const SQLITE_VERSION: &'static [u8; 6usize] = b"3.7.7\0"; pub const SQLITE_VERSION_NUMBER: i32 = 3007007; pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = - b"2011-06-23 19:49:22 4374b7e83ea0a3fbc3691f9c0c936272862f32f2\x00"; + b"2011-06-23 19:49:22 4374b7e83ea0a3fbc3691f9c0c936272862f32f2\0"; pub const SQLITE_OK: i32 = 0; pub const SQLITE_ERROR: i32 = 1; pub const SQLITE_INTERNAL: i32 = 2; @@ -258,7 +258,7 @@ pub const SQLITE_REPLACE: i32 = 5; pub type va_list = __builtin_va_list; pub type __gnuc_va_list = __builtin_va_list; extern "C" { - #[link_name = "sqlite3_version"] + #[link_name = "\u{1}sqlite3_version"] pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; } extern "C" { @@ -271,19 +271,21 @@ extern "C" { pub fn sqlite3_libversion_number() -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_compileoption_used(zOptName: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_compileoption_used( + zOptName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_compileoption_get(N: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_compileoption_get(N: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; } extern "C" { pub fn sqlite3_threadsafe() -> ::std::os::raw::c_int; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3([u8; 0]); +pub struct sqlite3 { + _unused: [u8; 0], +} pub type sqlite_int64 = ::std::os::raw::c_longlong; pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; pub type sqlite3_int64 = sqlite_int64; @@ -291,160 +293,348 @@ pub type sqlite3_uint64 = sqlite_uint64; extern "C" { pub fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int; } -pub type sqlite3_callback = - ::std::option::Option ::std::os::raw::c_int>; -extern "C" { - pub fn sqlite3_exec(arg1: *mut sqlite3, - sql: *const ::std::os::raw::c_char, - callback: - ::std::option::Option - ::std::os::raw::c_int>, - arg2: *mut ::std::os::raw::c_void, - errmsg: *mut *mut ::std::os::raw::c_char) - -> ::std::os::raw::c_int; +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +extern "C" { + pub fn sqlite3_exec( + arg1: *mut sqlite3, + sql: *const ::std::os::raw::c_char, + callback: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg2: *mut ::std::os::raw::c_void, + errmsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_file { - pub pMethods: *const sqlite3_file_sqlite3_io_methods, -} -#[repr(C)] -#[derive(Debug, Copy)] -pub struct sqlite3_file_sqlite3_io_methods { - pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option ::std::os::raw::c_int>, - pub xRead: ::std::option::Option ::std::os::raw::c_int>, - pub xWrite: ::std::option::Option ::std::os::raw::c_int>, - pub xTruncate: ::std::option::Option ::std::os::raw::c_int>, - pub xSync: ::std::option::Option ::std::os::raw::c_int>, - pub xFileSize: ::std::option::Option ::std::os::raw::c_int>, - pub xLock: ::std::option::Option ::std::os::raw::c_int>, - pub xUnlock: ::std::option::Option ::std::os::raw::c_int>, - pub xCheckReservedLock: ::std::option::Option - ::std::os::raw::c_int>, - pub xFileControl: ::std::option::Option ::std::os::raw::c_int>, - pub xSectorSize: ::std::option::Option ::std::os::raw::c_int>, - pub xDeviceCharacteristics: ::std::option::Option - ::std::os::raw::c_int>, - pub xShmMap: ::std::option::Option ::std::os::raw::c_int>, - pub xShmLock: ::std::option::Option ::std::os::raw::c_int>, - pub xShmBarrier: ::std::option::Option, - pub xShmUnmap: ::std::option::Option ::std::os::raw::c_int>, + pub pMethods: *const sqlite3_io_methods, } #[test] -fn bindgen_test_layout_sqlite3_file_sqlite3_io_methods() { - assert_eq!(::std::mem::size_of::() , - 136usize); - assert_eq!(::std::mem::align_of::() , - 8usize); +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); } -impl Clone for sqlite3_file_sqlite3_io_methods { - fn clone(&self) -> Self { *self } +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xShmMap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iPg: ::std::os::raw::c_int, + pgsz: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xShmLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + offset: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xShmBarrier: ::std::option::Option, + pub xShmUnmap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + deleteFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, } #[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!(::std::mem::size_of::() , 8usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_file { - fn clone(&self) -> Self { *self } +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 136usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmMap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmBarrier) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmUnmap) + ) + ); } -pub type sqlite3_io_methods = sqlite3_file_sqlite3_io_methods; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex([u8; 0]); +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +pub type sqlite3_syscall_ptr = ::std::option::Option; #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_vfs { pub iVersion: ::std::os::raw::c_int, pub szOsFile: ::std::os::raw::c_int, @@ -452,124 +642,349 @@ pub struct sqlite3_vfs { pub pNext: *mut sqlite3_vfs, pub zName: *const ::std::os::raw::c_char, pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option ::std::os::raw::c_int>, - pub xDelete: ::std::option::Option ::std::os::raw::c_int>, - pub xAccess: ::std::option::Option ::std::os::raw::c_int>, - pub xFullPathname: ::std::option::Option ::std::os::raw::c_int>, - pub xDlOpen: ::std::option::Option *mut ::std::os::raw::c_void>, - pub xDlError: ::std::option::Option, - pub xDlSym: ::std::option::Option - ::std::option::Option>, - pub xDlClose: ::std::option::Option, - pub xRandomness: ::std::option::Option ::std::os::raw::c_int>, - pub xSleep: ::std::option::Option ::std::os::raw::c_int>, - pub xCurrentTime: ::std::option::Option ::std::os::raw::c_int>, - pub xGetLastError: ::std::option::Option ::std::os::raw::c_int>, - pub xCurrentTimeInt64: ::std::option::Option - ::std::os::raw::c_int>, - pub xSetSystemCall: ::std::option::Option ::std::os::raw::c_int>, - pub xGetSystemCall: ::std::option::Option - ::std::option::Option>, - pub xNextSystemCall: ::std::option::Option - *const ::std::os::raw::c_char>, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTimeInt64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xSetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: sqlite3_syscall_ptr, + ) -> ::std::os::raw::c_int, + >, + pub xGetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> sqlite3_syscall_ptr, + >, + pub xNextSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, } #[test] fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!(::std::mem::size_of::() , 168usize); - assert_eq!(::std::mem::align_of::() , 8usize); + assert_eq!( + ::std::mem::size_of::(), + 168usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTimeInt64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xNextSystemCall) + ) + ); } -impl Clone for sqlite3_vfs { - fn clone(&self) -> Self { *self } -} -pub type sqlite3_syscall_ptr = ::std::option::Option; extern "C" { pub fn sqlite3_initialize() -> ::std::os::raw::c_int; } @@ -583,52 +998,138 @@ extern "C" { pub fn sqlite3_os_end() -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) - -> ::std::os::raw::c_int; + pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_db_config(arg1: *mut sqlite3, - op: ::std::os::raw::c_int, ...) - -> ::std::os::raw::c_int; + pub fn sqlite3_db_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option *mut ::std::os::raw::c_void>, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option *mut ::std::os::raw::c_void>, - pub xSize: ::std::option::Option ::std::os::raw::c_int>, - pub xRoundup: ::std::option::Option ::std::os::raw::c_int>, - pub xInit: ::std::option::Option ::std::os::raw::c_int>, - pub xShutdown: ::std::option::Option, + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, pub pAppData: *mut ::std::os::raw::c_void, } #[test] fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!(::std::mem::size_of::() , 64usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_mem_methods { - fn clone(&self) -> Self { *self } -} -extern "C" { - pub fn sqlite3_extended_result_codes(arg1: *mut sqlite3, - onoff: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +extern "C" { + pub fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + onoff: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite3_int64; @@ -643,71 +1144,76 @@ extern "C" { pub fn sqlite3_interrupt(arg1: *mut sqlite3); } extern "C" { - pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_busy_handler(arg1: *mut sqlite3, - arg2: - ::std::option::Option - ::std::os::raw::c_int>, - arg3: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_busy_timeout(arg1: *mut sqlite3, ms: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_get_table(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - pazResult: *mut *mut *mut ::std::os::raw::c_char, - pnRow: *mut ::std::os::raw::c_int, - pnColumn: *mut ::std::os::raw::c_int, - pzErrmsg: *mut *mut ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_get_table( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + pazResult: *mut *mut *mut ::std::os::raw::c_char, + pnRow: *mut ::std::os::raw::c_int, + pnColumn: *mut ::std::os::raw::c_int, + pzErrmsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char); } extern "C" { pub fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char, ...) - -> *mut ::std::os::raw::c_char; + -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_vmprintf(arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag) - -> *mut ::std::os::raw::c_char; + pub fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_snprintf(arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, ...) - -> *mut ::std::os::raw::c_char; + pub fn sqlite3_snprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_vsnprintf(arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut __va_list_tag) - -> *mut ::std::os::raw::c_char; + pub fn sqlite3_vsnprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_realloc(arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; } extern "C" { pub fn sqlite3_free(arg1: *mut ::std::os::raw::c_void); @@ -716,444 +1222,467 @@ extern "C" { pub fn sqlite3_memory_used() -> sqlite3_int64; } extern "C" { - pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) - -> sqlite3_int64; + pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) -> sqlite3_int64; } extern "C" { - pub fn sqlite3_randomness(N: ::std::os::raw::c_int, - P: *mut ::std::os::raw::c_void); + pub fn sqlite3_randomness(N: ::std::os::raw::c_int, P: *mut ::std::os::raw::c_void); } extern "C" { - pub fn sqlite3_set_authorizer(arg1: *mut sqlite3, - xAuth: - ::std::option::Option - ::std::os::raw::c_int>, - pUserData: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + xAuth: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pUserData: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_trace(arg1: *mut sqlite3, - xTrace: - ::std::option::Option, - arg2: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_profile(arg1: *mut sqlite3, - xProfile: - ::std::option::Option, - arg2: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_profile( + arg1: *mut sqlite3, + xProfile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_progress_handler(arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: - ::std::option::Option - ::std::os::raw::c_int>, - arg4: *mut ::std::os::raw::c_void); + pub fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ); } extern "C" { - pub fn sqlite3_open(filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3) -> ::std::os::raw::c_int; + pub fn sqlite3_open( + filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_open16(filename: *const ::std::os::raw::c_void, - ppDb: *mut *mut sqlite3) -> ::std::os::raw::c_int; + pub fn sqlite3_open16( + filename: *const ::std::os::raw::c_void, + ppDb: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_open_v2(filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3, - flags: ::std::os::raw::c_int, - zVfs: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_open_v2( + filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3, + flags: ::std::os::raw::c_int, + zVfs: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_uri_parameter(zFilename: *const ::std::os::raw::c_char, - zParam: *const ::std::os::raw::c_char) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_uri_parameter( + zFilename: *const ::std::os::raw::c_char, + zParam: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char; } extern "C" { pub fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_extended_errcode(db: *mut sqlite3) - -> ::std::os::raw::c_int; + pub fn sqlite3_extended_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_errmsg(arg1: *mut sqlite3) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_errmsg16(arg1: *mut sqlite3) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt([u8; 0]); +pub struct sqlite3_stmt { + _unused: [u8; 0], +} extern "C" { - pub fn sqlite3_limit(arg1: *mut sqlite3, id: ::std::os::raw::c_int, - newVal: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_limit( + arg1: *mut sqlite3, + id: ::std::os::raw::c_int, + newVal: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_prepare( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare_v2(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_prepare_v2( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare16(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_prepare16( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare16_v2(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_prepare16_v2( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_stmt_readonly(pStmt: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_stmt_readonly(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct Mem([u8; 0]); +pub struct Mem { + _unused: [u8; 0], +} pub type sqlite3_value = Mem; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_context([u8; 0]); +pub struct sqlite3_context { + _unused: [u8; 0], +} extern "C" { - pub fn sqlite3_bind_blob(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: - ::std::option::Option) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_double(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, arg3: f64) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_int(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_int64(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_int64) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_int64, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_null(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_text(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: - ::std::option::Option) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_text16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: - ::std::option::Option) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_value(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_zeroblob(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - n: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_parameter_name(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_bind_parameter_index(arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_name(arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_name16(arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_database_name(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_database_name16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_table_name(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_table_name16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_origin_name(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_origin_name16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_decltype(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_decltype16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { pub fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_blob(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_bytes(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_bytes16(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) -> f64; + pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64; } extern "C" { - pub fn sqlite3_column_int(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_int64(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) -> sqlite3_int64; + pub fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> sqlite3_int64; } extern "C" { - pub fn sqlite3_column_text(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_uchar; + pub fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar; } extern "C" { - pub fn sqlite3_column_text16(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_type(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_value(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> *mut sqlite3_value; + pub fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value; } extern "C" { - pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_create_function(db: *mut sqlite3, - zFunctionName: - *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: - ::std::option::Option, - xStep: - ::std::option::Option, - xFinal: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function16(db: *mut sqlite3, - zFunctionName: - *const ::std::os::raw::c_void, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: - ::std::option::Option, - xStep: - ::std::option::Option, - xFinal: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function_v2(db: *mut sqlite3, - zFunctionName: - *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: - ::std::option::Option, - xStep: - ::std::option::Option, - xFinal: - ::std::option::Option, - xDestroy: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) - -> ::std::os::raw::c_int; + pub fn sqlite3_create_function( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function16( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_void, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function_v2( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_transfer_bindings(arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_global_recover() -> ::std::os::raw::c_int; @@ -1162,111 +1691,106 @@ extern "C" { pub fn sqlite3_thread_cleanup(); } extern "C" { - pub fn sqlite3_memory_alarm(arg1: - ::std::option::Option, - arg2: *mut ::std::os::raw::c_void, - arg3: sqlite3_int64) -> ::std::os::raw::c_int; + pub fn sqlite3_memory_alarm( + arg1: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_int64, + arg3: ::std::os::raw::c_int, + ), + >, + arg2: *mut ::std::os::raw::c_void, + arg3: sqlite3_int64, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64; } extern "C" { - pub fn sqlite3_value_int(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite3_int64; } extern "C" { - pub fn sqlite3_value_text(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_uchar; + pub fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar; } extern "C" { - pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_type(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_aggregate_context(arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_user_data(arg1: *mut sqlite3_context) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) - -> *mut sqlite3; + pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3; } extern "C" { - pub fn sqlite3_get_auxdata(arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_set_auxdata(arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - arg3: - ::std::option::Option); + pub fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option, + ); } pub type sqlite3_destructor_type = - ::std::option::Option; + ::std::option::Option; extern "C" { - pub fn sqlite3_result_blob(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); + pub fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); } extern "C" { pub fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64); } extern "C" { - pub fn sqlite3_result_error(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int); + pub fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ); } extern "C" { - pub fn sqlite3_result_error16(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int); + pub fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ); } extern "C" { pub fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context); @@ -1275,211 +1799,187 @@ extern "C" { pub fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context); } extern "C" { - pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int); + pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_result_int(arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int); + pub fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, - arg2: sqlite3_int64); + pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite3_int64); } extern "C" { pub fn sqlite3_result_null(arg1: *mut sqlite3_context); } extern "C" { - pub fn sqlite3_result_text(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); -} -extern "C" { - pub fn sqlite3_result_text16(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); -} -extern "C" { - pub fn sqlite3_result_text16le(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); -} -extern "C" { - pub fn sqlite3_result_text16be(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); -} -extern "C" { - pub fn sqlite3_result_value(arg1: *mut sqlite3_context, - arg2: *mut sqlite3_value); -} -extern "C" { - pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, - n: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_create_collation(arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - xCompare: - ::std::option::Option - ::std::os::raw::c_int>) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation_v2(arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - xCompare: - ::std::option::Option - ::std::os::raw::c_int>, - xDestroy: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation16(arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_void, - eTextRep: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - xCompare: - ::std::option::Option - ::std::os::raw::c_int>) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed(arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed16(arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; -} -extern "C" { - #[link_name = "sqlite3_temp_directory"] + pub fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value); +} +extern "C" { + pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, n: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_create_collation( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation16( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_void, + eTextRep: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "\u{1}sqlite3_temp_directory"] pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) - -> ::std::os::raw::c_int; + pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3; } extern "C" { - pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) - -> *mut sqlite3_stmt; + pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) -> *mut sqlite3_stmt; } extern "C" { - pub fn sqlite3_commit_hook(arg1: *mut sqlite3, - arg2: - ::std::option::Option - ::std::os::raw::c_int>, - arg3: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_rollback_hook(arg1: *mut sqlite3, - arg2: - ::std::option::Option, - arg3: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_update_hook(arg1: *mut sqlite3, - arg2: - ::std::option::Option, - arg3: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_soft_heap_limit64(N: sqlite3_int64) -> sqlite3_int64; @@ -1488,60 +1988,418 @@ extern "C" { pub fn sqlite3_soft_heap_limit(N: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_table_column_metadata(db: *mut sqlite3, - zDbName: - *const ::std::os::raw::c_char, - zTableName: - *const ::std::os::raw::c_char, - zColumnName: - *const ::std::os::raw::c_char, - pzDataType: - *mut *const ::std::os::raw::c_char, - pzCollSeq: - *mut *const ::std::os::raw::c_char, - pNotNull: *mut ::std::os::raw::c_int, - pPrimaryKey: - *mut ::std::os::raw::c_int, - pAutoinc: *mut ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_table_column_metadata( + db: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + zTableName: *const ::std::os::raw::c_char, + zColumnName: *const ::std::os::raw::c_char, + pzDataType: *mut *const ::std::os::raw::c_char, + pzCollSeq: *mut *const ::std::os::raw::c_char, + pNotNull: *mut ::std::os::raw::c_int, + pPrimaryKey: *mut ::std::os::raw::c_int, + pAutoinc: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_load_extension(db: *mut sqlite3, - zFile: *const ::std::os::raw::c_char, - zProc: *const ::std::os::raw::c_char, - pzErrMsg: *mut *mut ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_load_extension( + db: *mut sqlite3, + zFile: *const ::std::os::raw::c_char, + zProc: *const ::std::os::raw::c_char, + pzErrMsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_enable_load_extension(db: *mut sqlite3, - onoff: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_enable_load_extension( + db: *mut sqlite3, + onoff: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_auto_extension(xEntryPoint: - ::std::option::Option) - -> ::std::os::raw::c_int; + pub fn sqlite3_auto_extension( + xEntryPoint: ::std::option::Option, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_reset_auto_extension(); } #[repr(C)] -#[derive(Debug, Copy)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSavepoint: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRelease: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRollbackTo: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, } #[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!(::std::mem::size_of::() , 24usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_vtab { - fn clone(&self) -> Self { *self } +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 184usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSavepoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRelease) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollbackTo) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_index_info { pub nConstraint: ::std::os::raw::c_int, pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, @@ -1555,7 +2413,7 @@ pub struct sqlite3_index_info { pub estimatedCost: f64, } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_index_info_sqlite3_index_constraint { pub iColumn: ::std::os::raw::c_int, pub op: ::std::os::raw::c_uchar, @@ -1564,294 +2422,464 @@ pub struct sqlite3_index_info_sqlite3_index_constraint { } #[test] fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!(::std::mem::size_of::() - , 12usize); - assert_eq!(::std::mem::align_of::() - , 4usize); -} -impl Clone for sqlite3_index_info_sqlite3_index_constraint { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_index_info_sqlite3_index_orderby { pub iColumn: ::std::os::raw::c_int, pub desc: ::std::os::raw::c_uchar, } #[test] fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!(::std::mem::size_of::() - , 8usize); - assert_eq!(::std::mem::align_of::() - , 4usize); -} -impl Clone for sqlite3_index_info_sqlite3_index_orderby { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_index_info_sqlite3_index_constraint_usage { pub argvIndex: ::std::os::raw::c_int, pub omit: ::std::os::raw::c_uchar, } #[test] fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!(::std::mem::size_of::() - , 8usize); - assert_eq!(::std::mem::align_of::() - , 4usize); -} -impl Clone for sqlite3_index_info_sqlite3_index_constraint_usage { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); } #[test] fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!(::std::mem::size_of::() , 72usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_index_info { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); +} +extern "C" { + pub fn sqlite3_create_module( + db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + p: *const sqlite3_module, + pClientData: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_module_v2( + db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + p: *const sqlite3_module, + pClientData: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy)] -pub struct sqlite3_vtab_cursor { - pub pVtab: *mut sqlite3_vtab, +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, } #[test] -fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!(::std::mem::size_of::() , 8usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_vtab_cursor { - fn clone(&self) -> Self { *self } +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option ::std::os::raw::c_int>, - pub xConnect: ::std::option::Option ::std::os::raw::c_int>, - pub xBestIndex: ::std::option::Option ::std::os::raw::c_int>, - pub xDisconnect: ::std::option::Option ::std::os::raw::c_int>, - pub xDestroy: ::std::option::Option ::std::os::raw::c_int>, - pub xOpen: ::std::option::Option ::std::os::raw::c_int>, - pub xClose: ::std::option::Option ::std::os::raw::c_int>, - pub xFilter: ::std::option::Option ::std::os::raw::c_int>, - pub xNext: ::std::option::Option ::std::os::raw::c_int>, - pub xEof: ::std::option::Option ::std::os::raw::c_int>, - pub xColumn: ::std::option::Option ::std::os::raw::c_int>, - pub xRowid: ::std::option::Option ::std::os::raw::c_int>, - pub xUpdate: ::std::option::Option ::std::os::raw::c_int>, - pub xBegin: ::std::option::Option ::std::os::raw::c_int>, - pub xSync: ::std::option::Option ::std::os::raw::c_int>, - pub xCommit: ::std::option::Option ::std::os::raw::c_int>, - pub xRollback: ::std::option::Option ::std::os::raw::c_int>, - pub xFindFunction: ::std::option::Option, - ppArg: - *mut *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int>, - pub xRename: ::std::option::Option ::std::os::raw::c_int>, - pub xSavepoint: ::std::option::Option ::std::os::raw::c_int>, - pub xRelease: ::std::option::Option ::std::os::raw::c_int>, - pub xRollbackTo: ::std::option::Option ::std::os::raw::c_int>, +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, } #[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!(::std::mem::size_of::() , 184usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_module { - fn clone(&self) -> Self { *self } -} -extern "C" { - pub fn sqlite3_create_module(db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - p: *const sqlite3_module, - pClientData: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_module_v2(db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - p: *const sqlite3_module, - pClientData: *mut ::std::os::raw::c_void, - xDestroy: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_declare_vtab(arg1: *mut sqlite3, - zSQL: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_overload_function(arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +extern "C" { + pub fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + zSQL: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob([u8; 0]); +pub struct sqlite3_blob { + _unused: [u8; 0], +} extern "C" { - pub fn sqlite3_blob_open(arg1: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - zTable: *const ::std::os::raw::c_char, - zColumn: *const ::std::os::raw::c_char, - iRow: sqlite3_int64, - flags: ::std::os::raw::c_int, - ppBlob: *mut *mut sqlite3_blob) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_open( + arg1: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + zTable: *const ::std::os::raw::c_char, + zColumn: *const ::std::os::raw::c_char, + iRow: sqlite3_int64, + flags: ::std::os::raw::c_int, + ppBlob: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_reopen(arg1: *mut sqlite3_blob, arg2: sqlite3_int64) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_reopen( + arg1: *mut sqlite3_blob, + arg2: sqlite3_int64, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_read(arg1: *mut sqlite3_blob, - Z: *mut ::std::os::raw::c_void, - N: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + Z: *mut ::std::os::raw::c_void, + N: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_write(arg1: *mut sqlite3_blob, - z: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + z: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) - -> *mut sqlite3_vfs; + pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs; } extern "C" { - pub fn sqlite3_vfs_register(arg1: *mut sqlite3_vfs, - makeDflt: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + makeDflt: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) - -> ::std::os::raw::c_int; + pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) - -> *mut sqlite3_mutex; + pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex; } extern "C" { pub fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex); @@ -1860,286 +2888,622 @@ extern "C" { pub fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex); } extern "C" { - pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) - -> ::std::os::raw::c_int; + pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option *mut sqlite3_mutex>, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexNotheld: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, } #[test] fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!(::std::mem::size_of::() , 72usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_mutex_methods { - fn clone(&self) -> Self { *self } -} -extern "C" { - pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) - -> ::std::os::raw::c_int; + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +extern "C" { + pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex; } extern "C" { - pub fn sqlite3_file_control(arg1: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - op: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_file_control( + arg1: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + op: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) - -> ::std::os::raw::c_int; + pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_status(op: ::std::os::raw::c_int, - pCurrent: *mut ::std::os::raw::c_int, - pHighwater: *mut ::std::os::raw::c_int, - resetFlag: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_status( + op: ::std::os::raw::c_int, + pCurrent: *mut ::std::os::raw::c_int, + pHighwater: *mut ::std::os::raw::c_int, + resetFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_db_status(arg1: *mut sqlite3, op: ::std::os::raw::c_int, - pCur: *mut ::std::os::raw::c_int, - pHiwtr: *mut ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_db_status( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + pCur: *mut ::std::os::raw::c_int, + pHiwtr: *mut ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_stmt_status(arg1: *mut sqlite3_stmt, - op: ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_stmt_status( + arg1: *mut sqlite3_stmt, + op: ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache([u8; 0]); +pub struct sqlite3_pcache { + _unused: [u8; 0], +} #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_pcache_methods { pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option ::std::os::raw::c_int>, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option *mut sqlite3_pcache>, - pub xCachesize: ::std::option::Option, - pub xPagecount: ::std::option::Option ::std::os::raw::c_int>, - pub xFetch: ::std::option::Option *mut ::std::os::raw::c_void>, - pub xUnpin: ::std::option::Option, - pub xRekey: ::std::option::Option, - pub xTruncate: ::std::option::Option, - pub xDestroy: ::std::option::Option, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, } #[test] fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!(::std::mem::size_of::() , 88usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_pcache_methods { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_backup([u8; 0]); +pub struct sqlite3_backup { + _unused: [u8; 0], +} extern "C" { - pub fn sqlite3_backup_init(pDest: *mut sqlite3, - zDestName: *const ::std::os::raw::c_char, - pSource: *mut sqlite3, - zSourceName: *const ::std::os::raw::c_char) - -> *mut sqlite3_backup; + pub fn sqlite3_backup_init( + pDest: *mut sqlite3, + zDestName: *const ::std::os::raw::c_char, + pSource: *mut sqlite3, + zSourceName: *const ::std::os::raw::c_char, + ) -> *mut sqlite3_backup; } extern "C" { - pub fn sqlite3_backup_step(p: *mut sqlite3_backup, - nPage: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_backup_step( + p: *mut sqlite3_backup, + nPage: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_backup_finish(p: *mut sqlite3_backup) - -> ::std::os::raw::c_int; + pub fn sqlite3_backup_finish(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_backup_remaining(p: *mut sqlite3_backup) - -> ::std::os::raw::c_int; + pub fn sqlite3_backup_remaining(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_backup_pagecount(p: *mut sqlite3_backup) - -> ::std::os::raw::c_int; + pub fn sqlite3_backup_pagecount(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_unlock_notify(pBlocked: *mut sqlite3, - xNotify: - ::std::option::Option, - pNotifyArg: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_unlock_notify( + pBlocked: *mut sqlite3, + xNotify: ::std::option::Option< + unsafe extern "C" fn( + apArg: *mut *mut ::std::os::raw::c_void, + nArg: ::std::os::raw::c_int, + ), + >, + pNotifyArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_strnicmp(arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_strnicmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_log(iErrCode: ::std::os::raw::c_int, - zFormat: *const ::std::os::raw::c_char, ...); + pub fn sqlite3_log( + iErrCode: ::std::os::raw::c_int, + zFormat: *const ::std::os::raw::c_char, + ... + ); } extern "C" { - pub fn sqlite3_wal_hook(arg1: *mut sqlite3, - arg2: - ::std::option::Option - ::std::os::raw::c_int>, - arg3: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_wal_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_wal_autocheckpoint(db: *mut sqlite3, - N: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_wal_autocheckpoint( + db: *mut sqlite3, + N: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_wal_checkpoint(db: *mut sqlite3, - zDb: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_wal_checkpoint( + db: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_wal_checkpoint_v2(db: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - eMode: ::std::os::raw::c_int, - pnLog: *mut ::std::os::raw::c_int, - pnCkpt: *mut ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_wal_checkpoint_v2( + db: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + eMode: ::std::os::raw::c_int, + pnLog: *mut ::std::os::raw::c_int, + pnCkpt: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_vtab_config(arg1: *mut sqlite3, - op: ::std::os::raw::c_int, ...) - -> ::std::os::raw::c_int; + pub fn sqlite3_vtab_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) - -> ::std::os::raw::c_int; + pub fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_rtree_geometry_callback( + db: *mut sqlite3, + zGeom: *const ::std::os::raw::c_char, + xGeom: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_rtree_geometry, + nCoord: ::std::os::raw::c_int, + aCoord: *mut f64, + pRes: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pContext: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_rtree_geometry { pub pContext: *mut ::std::os::raw::c_void, pub nParam: ::std::os::raw::c_int, pub aParam: *mut f64, pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, + pub xDelUser: ::std::option::Option, } #[test] fn bindgen_test_layout_sqlite3_rtree_geometry() { - assert_eq!(::std::mem::size_of::() , 40usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_rtree_geometry { - fn clone(&self) -> Self { *self } -} -extern "C" { - pub fn sqlite3_rtree_geometry_callback(db: *mut sqlite3, - zGeom: - *const ::std::os::raw::c_char, - xGeom: - ::std::option::Option - ::std::os::raw::c_int>, - pContext: - *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(xDelUser) + ) + ); } +pub type __builtin_va_list = [__va_list_tag; 1usize]; #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct __va_list_tag { pub gp_offset: ::std::os::raw::c_uint, pub fp_offset: ::std::os::raw::c_uint, pub overflow_arg_area: *mut ::std::os::raw::c_void, pub reg_save_area: *mut ::std::os::raw::c_void, } -impl Clone for __va_list_tag { - fn clone(&self) -> Self { *self } +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); } -pub type __builtin_va_list = [__va_list_tag; 1usize]; - pub const SQLITE_DETERMINISTIC: i32 = 2048; diff --git a/libsqlite3-sys/bindgen-bindings/generate-bindgen-bindings.sh b/libsqlite3-sys/bindgen-bindings/generate-bindgen-bindings.sh new file mode 100755 index 000000000..a2d31b3fa --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/generate-bindgen-bindings.sh @@ -0,0 +1,78 @@ +#!/bin/bash +############################################################################### +# Copyright (c) 2019 Genomics plc +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +############################################################################### +set -euf -o pipefail + +SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )" + +build_dir=$(mktemp -d) +function cleanup { + >&2 echo "deleting ${build_dir}" + rm -rf "${build_dir}" +} +trap cleanup EXIT + +function generate_bindgen_bindings() { + version=$1 + url=$2 + prefix=$3 + + >&2 echo "generating bindgen bindings for sqlite3 ${version} in ${build_dir}" + curl -sSf -o "${build_dir}/sqlite-amalgamation-${version}.zip" "${url}" + mkdir "${build_dir}/sqlite-${version}" + unzip -qq -d "${build_dir}/sqlite-${version}" "${build_dir}/sqlite-amalgamation-${version}.zip" + export SQLITE3_LIB_DIR="${build_dir}/sqlite-${version}/${prefix}" + export SQLITE3_INCLUDE_DIR="${build_dir}/sqlite-${version}/${prefix}" + manifest="${SCRIPT_DIR}/../Cargo.toml" + generate_bindgen_binding "${manifest}" "${build_dir}" "${SCRIPT_DIR}" "buildtime_bindgen" "${version}" + generate_bindgen_binding "${manifest}" "${build_dir}" "${SCRIPT_DIR}" "buildtime_bindgen,loadable_extension" "${version}-ext" + generate_bindgen_binding "${manifest}" "${build_dir}" "${SCRIPT_DIR}" "buildtime_bindgen,loadable_extension_embedded" "${version}-ext-embed" + >&2 echo "done generating bindings for sqlite ${version}" +} + +function generate_bindgen_binding { + manifest_path=$1 + build_dir=$2 + output_dir=$3 + features=$4 + output_base=$5 + + target_dir="${build_dir}/${output_base}/target" + output_path="${output_dir}/bindgen_${output_base}.rs" + + >&2 echo "calling cargo build on manifest ${manifest_path} building in ${target_dir} with features ${features}" + cargo build --manifest-path "${manifest_path}" --target-dir "${target_dir}" --features "${features}" -p libsqlite3-sys + bindgen_file=$(set +f ; find "${target_dir}/debug/build/libsqlite3-sys-"* -name bindgen.rs ; set -f) + if [[ "$(echo "${bindgen_file}" | wc -l)" != 1 ]]; then + >&2 echo "multiple bindgen files found in target directory: ${bindgen_file}" + exit 2 + fi + cp "${bindgen_file}" "${output_path}" +} + +generate_bindgen_bindings 3.26.0 https://sqlite.org/2018/sqlite-amalgamation-3260000.zip sqlite-amalgamation-3260000/ +generate_bindgen_bindings 3.20.0 https://sqlite.org/2017/sqlite-amalgamation-3200000.zip sqlite-amalgamation-3200000/ +generate_bindgen_bindings 3.13.0 https://sqlite.org/2016/sqlite-amalgamation-3130000.zip sqlite-amalgamation-3130000/ +generate_bindgen_bindings 3.7.16 https://sqlite.org/2013/sqlite-amalgamation-3071600.zip sqlite-amalgamation-3071600/ +generate_bindgen_bindings 3.7.7 https://sqlite.org/sqlite-amalgamation-3070700.zip sqlite-amalgamation-3070700/ +generate_bindgen_bindings 3.6.23 https://sqlite.org/sqlite-amalgamation-3_6_23.zip ./ +generate_bindgen_bindings 3.6.8 https://sqlite.org/sqlite-amalgamation-3_6_8.zip ./ diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index e6942d019..9d24bb271 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -1,3 +1,25 @@ +//***************************************************************************** +// Copyright (c) 2014 John Gallagher +// Copyright (c) 2019 Genomics plc +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE +//***************************************************************************** use std::env; use std::path::Path; @@ -16,17 +38,25 @@ fn main() { // This can't be `cfg!` without always requiring our `mod build_bundled` (and thus `cc`) #[cfg(feature = "bundled")] { + if cfg!(feature = "loadable_extension") { + panic!("Building a loadable extension bundled is not supported"); + } build_bundled::main(&out_dir, &out_path) } #[cfg(not(feature = "bundled"))] { - build_linked::main(&out_dir, &out_path) + if cfg!(feature = "loadable_extension") { + build_loadable_extension::main(&out_dir, &out_path) + } else { + build_linked::main(&out_dir, &out_path) + } } } } #[cfg(feature = "bundled")] mod build_bundled { + use super::header_file; use cc; use std::path::Path; @@ -39,7 +69,7 @@ mod build_bundled { #[cfg(feature = "buildtime_bindgen")] { use super::{bindings, HeaderLocation}; - let header = HeaderLocation::FromPath("sqlite3/sqlite3.h".to_owned()); + let header = HeaderLocation::FromPath(format!("sqlite3/{}", header_file()).to_owned()); bindings::write_to_out_dir(header, out_path); } #[cfg(not(feature = "buildtime_bindgen"))] @@ -93,6 +123,22 @@ fn env_prefix() -> &'static str { } } +fn header_file() -> &'static str { + if cfg!(feature = "loadable_extension") { + "sqlite3ext.h" + } else { + "sqlite3.h" + } +} + +fn wrapper_file() -> &'static str { + if cfg!(feature = "loadable_extension") { + "wrapper-ext.h" + } else { + "wrapper.h" + } +} + pub enum HeaderLocation { FromEnvironment, Wrapper, @@ -108,10 +154,11 @@ impl From for String { "{}_INCLUDE_DIR must be set if {}_LIB_DIR is set", prefix, prefix )); - header.push_str("/sqlite3.h"); + header.push_str("/"); + header.push_str(header_file()); header } - HeaderLocation::Wrapper => "wrapper.h".into(), + HeaderLocation::Wrapper => wrapper_file().into(), HeaderLocation::FromPath(path) => path, } } @@ -123,7 +170,7 @@ mod build_linked { #[cfg(all(feature = "vcpkg", target_env = "msvc"))] extern crate vcpkg; - use super::{bindings, env_prefix, HeaderLocation}; + use super::{bindings, env_prefix, header_file, HeaderLocation}; use std::env; use std::path::Path; @@ -190,7 +237,7 @@ mod build_linked { { Ok(mut lib) => { if let Some(mut header) = lib.include_paths.pop() { - header.push("sqlite3.h"); + header.push(header_file()); HeaderLocation::FromPath(header.to_string_lossy().into()) } else { HeaderLocation::Wrapper @@ -212,7 +259,7 @@ mod build_linked { // See if vcpkg can find it. if let Ok(mut lib) = vcpkg::Config::new().probe(link_lib()) { if let Some(mut header) = lib.include_paths.pop() { - header.push("sqlite3.h"); + header.push(header_file()); return Some(HeaderLocation::FromPath(header.to_string_lossy().into())); } } @@ -233,6 +280,79 @@ mod build_linked { } } +mod build_loadable_extension { + use pkg_config; + + use super::{bindings, env_prefix, header_file, HeaderLocation}; + use std::env; + use std::path::Path; + + pub fn main(_out_dir: &str, out_path: &Path) { + let header = find_sqlite(); + bindings::write_to_out_dir(header, out_path); + } + + // Prints the necessary cargo link commands and returns the path to the header. + fn find_sqlite() -> HeaderLocation { + let link_lib = "sqlite3"; + + println!("cargo:rerun-if-env-changed={}_INCLUDE_DIR", env_prefix()); + println!("cargo:rerun-if-env-changed={}_LIB_DIR", env_prefix()); + println!("cargo:rerun-if-env-changed={}_STATIC", env_prefix()); + if cfg!(target_os = "windows") { + println!("cargo:rerun-if-env-changed=PATH"); + } + if cfg!(all(feature = "vcpkg", target_env = "msvc")) { + println!("cargo:rerun-if-env-changed=VCPKGRS_DYNAMIC"); + } + // Allow users to specify where to find SQLite. + if let Ok(dir) = env::var(format!("{}_LIB_DIR", env_prefix())) { + // Try to use pkg-config to determine link commands + let pkgconfig_path = Path::new(&dir).join("pkgconfig"); + env::set_var("PKG_CONFIG_PATH", pkgconfig_path); + return HeaderLocation::FromEnvironment; + } + + if let Some(header) = try_vcpkg() { + return header; + } + + // See if pkg-config can do everything for us. + match pkg_config::Config::new() + .print_system_libs(false) + .probe(link_lib) + { + Ok(mut lib) => { + if let Some(mut header) = lib.include_paths.pop() { + header.push(header_file()); + HeaderLocation::FromPath(header.to_string_lossy().into()) + } else { + HeaderLocation::Wrapper + } + } + Err(_) => HeaderLocation::Wrapper, + } + } + + #[cfg(all(feature = "vcpkg", target_env = "msvc"))] + fn try_vcpkg() -> Option { + // See if vcpkg can find it. + if let Ok(mut lib) = vcpkg::Config::new().probe(link_lib()) { + if let Some(mut header) = lib.include_paths.pop() { + header.push(header_file()); + return Some(HeaderLocation::FromPath(header.to_string_lossy().into())); + } + } + None + } + + #[cfg(not(all(feature = "vcpkg", target_env = "msvc")))] + fn try_vcpkg() -> Option { + None + } + +} + #[cfg(not(feature = "buildtime_bindgen"))] mod bindings { use super::HeaderLocation; @@ -241,19 +361,43 @@ mod bindings { use std::path::Path; static PREBUILT_BINDGEN_PATHS: &'static [&'static str] = &[ - "bindgen-bindings/bindgen_3.6.8.rs", + "bindgen-bindings/bindgen_3.6.8", #[cfg(feature = "min_sqlite_version_3_6_23")] - "bindgen-bindings/bindgen_3.6.23.rs", + "bindgen-bindings/bindgen_3.6.23", #[cfg(feature = "min_sqlite_version_3_7_7")] - "bindgen-bindings/bindgen_3.7.7.rs", + "bindgen-bindings/bindgen_3.7.7", #[cfg(feature = "min_sqlite_version_3_7_16")] - "bindgen-bindings/bindgen_3.7.16.rs", + "bindgen-bindings/bindgen_3.7.16", + #[cfg(feature = "min_sqlite_version_3_13_0")] + "bindgen-bindings/bindgen_3.13.0", + #[cfg(feature = "min_sqlite_version_3_20_0")] + "bindgen-bindings/bindgen_3.20.0", + #[cfg(feature = "min_sqlite_version_3_26_0")] + "bindgen-bindings/bindgen_3.26.0", ]; pub fn write_to_out_dir(_header: HeaderLocation, out_path: &Path) { - let in_path = PREBUILT_BINDGEN_PATHS[PREBUILT_BINDGEN_PATHS.len() - 1]; - fs::copy(in_path, out_path).expect("Could not copy bindings to output directory"); + let in_path = format!( + "{}{}.rs", + PREBUILT_BINDGEN_PATHS[PREBUILT_BINDGEN_PATHS.len() - 1], + prebuilt_bindgen_ext() + ); + fs::copy(in_path.to_owned(), out_path).expect(&format!( + "Could not copy bindings to output directory from {}", + in_path + )); + } + + fn prebuilt_bindgen_ext() -> &'static str { + if cfg!(feature = "loadable_extension_embedded") { + "-ext-embed" + } else if cfg!(feature = "loadable_extension") { + "-ext" + } else { + "" + } } + } #[cfg(feature = "buildtime_bindgen")] @@ -264,8 +408,10 @@ mod bindings { use super::HeaderLocation; use std::fs::OpenOptions; + use std::io::copy; use std::io::Write; use std::path::Path; + use std::process::{Command, Stdio}; #[derive(Debug)] struct SqliteTypeChooser; @@ -286,7 +432,7 @@ mod bindings { let mut bindings = bindgen::builder() .header(header.clone()) .parse_callbacks(Box::new(SqliteTypeChooser)) - .rustfmt_bindings(true); + .rustfmt_bindings(false); // we'll run rustfmt after (possibly) adding wrappers if cfg!(feature = "unlock_notify") { bindings = bindings.clang_arg("-DSQLITE_ENABLE_UNLOCK_NOTIFY"); @@ -298,6 +444,27 @@ mod bindings { bindings = bindings.clang_arg("-DSQLITE_ENABLE_SESSION"); } + // rust-bindgen does not handle CPP macros that alias functions, so + // when using sqlite3ext.h to support loadable extensions, the macros + // that attempt to redefine sqlite3 API routines to be redirected through + // the global sqlite3_api instance of the sqlite3_api_routines structure + // do not result in any code production. + // + // Before defining wrappers to take their place, we need to blacklist + // all sqlite3 API functions since none of their symbols will be + // available directly when being loaded as an extension. + #[cfg(feature = "loadable_extension")] + { + // some api functions do not have an implementation in sqlite3_api_routines + // (for example: sqlite3_config, sqlite3_initialize, sqlite3_interrupt, ...). + // while this isn't a problem for shared libraries (unless we actually try to + // call them, it is better to blacklist them all so that the build will fail + // if an attempt is made to call an extern function that we know won't exist + // and to avoid undefined symbol issues when linking the loadable extension + // rust code with other (e.g. non-rust) code + bindings = bindings.blacklist_function(".*"); + } + bindings .generate() .expect(&format!("could not run bindgen on header {}", header)) @@ -305,6 +472,92 @@ mod bindings { .expect("could not write output of bindgen"); let mut output = String::from_utf8(output).expect("bindgen output was not UTF-8?!"); + // Get the list of API functions supported by sqlite3_api_routines, + // set the corresponding sqlite3 api routine to be blacklisted in the + // final bindgen run, and add wrappers for each of the API functions to + // dispatch the API call through a sqlite3_api global, which is also + // declared in the bindings (either as a built-in or an extern symbol + // in the case of loadable_extension_embedded (i.e. when the rust code + // will be a part of an extension but not implement the extension + // entrypoint itself). + #[cfg(feature = "loadable_extension")] + { + let api_routines_struct_name = "sqlite3_api_routines".to_owned(); + + let api_routines_struct = match get_struct_by_name(&output, &api_routines_struct_name) { + Some(s) => s, + None => { + panic!( + "Failed to find struct {} in early bindgen output", + api_routines_struct_name + ); + } + }; + + #[cfg(feature = "loadable_extension_embedded")] + { + // an embedded loadable extension is one in which the rust code will be linked in to + // external code that implements the loadable extension and exports the sqlite3_api + // interface as a symbol + output.push_str( + r#" + +// bindings were built with loadable_extension_embedded: +// define sqlite3_api as an extern since this code will be embedded +// within a loadable extension that defines and exports this itself +extern { + #[no_mangle] + pub static mut sqlite3_api: *mut sqlite3_api_routines; +} + +"#, + ); + } + + #[cfg(not(feature = "loadable_extension_embedded"))] + { + // a non-embedded loadable extension is a standalone rust loadable extension, + // so we need our own sqlite3_api global + output.push_str( + r#" + +// bindings were built with (non-embedded) loadable_extension: +// we define our own sqlite_api static variable and export it +// to C +#[no_mangle] +pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_routines; + +"#, + ); + } + + output.push_str( + r" +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) + +"); + + // create wrapper for each field in api routines struct + for field in &api_routines_struct.fields { + let ident = match &field.ident { + Some(ident) => ident, + None => { + panic!("Unexpected anonymous field in sqlite"); + } + }; + let field_type = &field.ty; + + // construct global sqlite api function identifier from field identifier + let api_fn_name = format!("sqlite3_{}", ident); + + // generate wrapper function and push it to output string + let wrapper = generate_wrapper(ident, field_type, &api_fn_name); + output.push_str(&wrapper); + } + + output.push_str("\n"); + } + // rusqlite's functions feature ors in the SQLITE_DETERMINISTIC flag when it // can. This flag was added in SQLite 3.8.3, but oring it in in prior // versions of SQLite is harmless. We don't want to not build just @@ -322,7 +575,171 @@ mod bindings { .open(out_path.clone()) .expect(&format!("Could not write to {:?}", out_path)); - file.write_all(output.as_bytes()) + // pipe generated bindings through rustfmt + let rustfmt = which::which("rustfmt") + .expect("rustfmt not on PATH") + .to_owned(); + let mut cmd = Command::new(rustfmt); + cmd.stdin(Stdio::piped()).stdout(Stdio::piped()); + let mut rustfmt_child = cmd.spawn().expect("failed to execute rustfmt"); + let mut rustfmt_child_stdin = rustfmt_child.stdin.take().unwrap(); + let mut rustfmt_child_stdout = rustfmt_child.stdout.take().unwrap(); + + // spawn a thread to write output string to rustfmt stdin + let stdin_handle = ::std::thread::spawn(move || { + let _ = rustfmt_child_stdin.write_all(output.as_bytes()); + output + }); + + // read stdout of rustfmt and write it to bindings file at out_path + copy(&mut rustfmt_child_stdout, &mut file) .expect(&format!("Could not write to {:?}", out_path)); + + let status = rustfmt_child + .wait() + .expect("failed to wait for rustfmt to complete"); + stdin_handle + .join() + .expect("The impossible: writer to rustfmt stdin cannot panic"); + + match status.code() { + Some(0) => {} + Some(2) => { + panic!("rustfmt parsing error"); + } + Some(3) => { + panic!("rustfmt could not format some lines."); + } + _ => { + panic!("Internal rustfmt error"); + } + } + } + + #[cfg(feature = "loadable_extension")] + fn get_struct_by_name(bindgen_sources: &str, name: &str) -> Option { + let file = syn::parse_file(&bindgen_sources).expect("unable to parse early bindgen output"); + + for item in &file.items { + if let syn::Item::Struct(s) = item { + if s.ident == name { + return Some(s.to_owned()); + } + } + } + return None; + } + + #[cfg(feature = "loadable_extension")] + fn bare_fn_from_type_path(t: &syn::Type) -> syn::TypeBareFn { + let path = match t { + syn::Type::Path(tp) => &tp.path, + _ => { + panic!("type was not a type path"); + } + }; + + let mut path_args: Option = None; + for segment in &path.segments { + if segment.arguments.is_empty() { + continue; + } + path_args = Some(segment.arguments.to_owned()); + break; + } + match path_args { + Some(syn::PathArguments::AngleBracketed(p)) => { + for gen_arg in p.args { + match gen_arg { + syn::GenericArgument::Type(syn::Type::BareFn(bf)) => { + return bf; + } + _ => { + panic!("parsed type was not a bare function as expected"); + } + }; + } + } + _ => { + panic!("parsed path args were not angle bracketed as expected"); + } + }; + panic!("unexpected failure to parse bare function"); + } + + #[cfg(feature = "loadable_extension")] + fn generate_wrapper( + field_ident: &syn::Ident, + syn_type: &syn::Type, + api_fn_name: &str, + ) -> String { + use quote::quote; + use syn::Token; + + let field_name = field_ident.to_string(); + let api_fn_ident = syn::Ident::new(&api_fn_name, field_ident.span()); + + // add wrapper macro invocation to be appended to the generated bindings + let bare_fn = bare_fn_from_type_path(syn_type); + let api_fn_output = &bare_fn.output; + + // prepare inputs + let mut api_fn_inputs = bare_fn.inputs.clone(); + + // handle variadic api functions + if bare_fn.variadic.is_some() { + // until rust c_variadic support exists, we can't + // transparently wrap variadic api functions. + // generate specific set of args in place of + // variadic for each function we care about. + let var_arg_types: Vec> = match api_fn_name.as_ref() { + "sqlite3_db_config" => { + let mut_int_type: syn::TypeReference = syn::parse2(quote!(&mut i32)) + .expect("failed to parse mutable integer reference"); + vec![None, Some(syn::Type::Reference(mut_int_type))] + } + _ => vec![None], + }; + + for (index, var_arg_type) in var_arg_types.iter().enumerate() { + let mut input = api_fn_inputs[api_fn_inputs.len() - 1].clone(); + let input_ident = + syn::Ident::new(&format!("vararg{}", index + 1), field_ident.span()); + let colon = Token![:](field_ident.span()); + input.name = Some((syn::BareFnArgName::Named(input_ident), colon)); + match var_arg_type.to_owned() { + Some(t) => { + input.ty = t; + } + None => {} + }; + api_fn_inputs.push(input); + } + } + + // get identifiers for each of the inputs to use in the api call + let api_fn_input_idents: Vec = (&api_fn_inputs) + .into_iter() + .map(|input| match &input.name { + Some((syn::BareFnArgName::Named(ident), _)) => ident.to_owned(), + _ => { + panic!("Input has no name {:#?}", input); + } + }) + .collect(); + + // generate wrapper and return it as a string + let wrapper_tokens = quote! { + pub unsafe fn #api_fn_ident(#api_fn_inputs) #api_fn_output { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).#field_ident + .expect(stringify!("sqlite3_api contains null pointer for ", #field_name, " function")))( + #(#api_fn_input_idents),* + ) + } + }; + return format!("{}\n\n", wrapper_tokens.to_string()); } } diff --git a/libsqlite3-sys/wrapper-ext.h b/libsqlite3-sys/wrapper-ext.h new file mode 100644 index 000000000..ab1b1f9db --- /dev/null +++ b/libsqlite3-sys/wrapper-ext.h @@ -0,0 +1,2 @@ +#include "sqlite3ext.h" + diff --git a/src/inner_connection.rs b/src/inner_connection.rs index b54f3d466..7dd7406bc 100644 --- a/src/inner_connection.rs +++ b/src/inner_connection.rs @@ -281,7 +281,6 @@ impl Drop for InnerConnection { #[cfg(not(feature = "bundled"))] static SQLITE_VERSION_CHECK: Once = ONCE_INIT; -#[cfg(not(feature = "bundled"))] pub static BYPASS_VERSION_CHECK: AtomicBool = AtomicBool::new(false); #[cfg(not(feature = "bundled"))] @@ -328,9 +327,22 @@ rusqlite was built against SQLite {} but the runtime SQLite version is {}. To fi }); } -static SQLITE_INIT: Once = ONCE_INIT; pub static BYPASS_SQLITE_INIT: AtomicBool = AtomicBool::new(false); +// threading mode checks are not possible when built as a loadable extension +// since the sqlite3_threadsafe, sqlite3_config, and sqlite3_initialize +// API calls are not available via the sqlite3_api_routines struct. +// They are also not available when sqlite is built without threadsafe (e.g. -DSQLITE_THREADSAFE=0) +// which is represented here by the "non_threadsafe" feature. +#[cfg(any(feature = "loadable_extension", feature = "loadable_extension_embedded", feature= "non_threadsafe"))] +fn ensure_safe_sqlite_threading_mode() -> Result<()> { + Ok(()) +} + +#[cfg(not(any(feature = "loadable_extension", feature = "loadable_extension_embedded", feature= "non_threadsafe")))] +static SQLITE_INIT: Once = ONCE_INIT; + +#[cfg(not(any(feature = "loadable_extension", feature = "loadable_extension_embedded", feature= "non_threadsafe")))] fn ensure_safe_sqlite_threading_mode() -> Result<()> { // Ensure SQLite was compiled in thredsafe mode. if unsafe { ffi::sqlite3_threadsafe() == 0 } { diff --git a/src/lib.rs b/src/lib.rs index 250635e15..2a0e62801 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -60,6 +60,7 @@ pub use libsqlite3_sys as ffi; #[macro_use] extern crate bitflags; + #[cfg(any(test, feature = "vtab"))] #[macro_use] extern crate lazy_static; @@ -824,6 +825,7 @@ impl InterruptHandle { pub fn interrupt(&self) { let db_handle = self.db_lock.lock().unwrap(); if !db_handle.is_null() { + #[cfg(not(any(feature = "loadable_extension", feature = "loadable_extension_embedded")))] // no sqlite3_interrupt in a loadable extension unsafe { ffi::sqlite3_interrupt(*db_handle) } } } From 5c97c48fe0a08a8e41db528ae411b1dcb2653982 Mon Sep 17 00:00:00 2001 From: "Joshua C. Randall" Date: Sat, 15 Jun 2019 23:28:07 +0000 Subject: [PATCH 02/61] install rustfmt in travis ci --- .travis.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.travis.yml b/.travis.yml index 1cc49633e..fe2fc82cd 100644 --- a/.travis.yml +++ b/.travis.yml @@ -7,6 +7,8 @@ rust: - beta - nightly +before_script: rustup component add rustfmt + matrix: fast_finish: true allow_failures: From 4caff1491f4c380a33c4adc66025423d58d437e8 Mon Sep 17 00:00:00 2001 From: "Joshua C. Randall" Date: Sat, 15 Jun 2019 23:38:48 +0000 Subject: [PATCH 03/61] add rustfmt to appveyor install --- appveyor.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/appveyor.yml b/appveyor.yml index 469e49354..144c3840c 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -15,6 +15,7 @@ install: - if defined MSYS2_BITS set PATH=%PATH%;C:\msys64\mingw%MSYS2_BITS%\bin - rustc -V - cargo -V + - rustup component add rustfmt # download SQLite dll (useful only when the `bundled` feature is not set) - appveyor-retry appveyor DownloadFile https://sqlite.org/2018/sqlite-dll-win64-x64-3250200.zip -FileName sqlite-dll-win64-x64.zip - if not defined VCPKG_DEFAULT_TRIPLET 7z e sqlite-dll-win64-x64.zip -y > nul From b21aed20f037dbc3b2cff06bf4262ba1ff488099 Mon Sep 17 00:00:00 2001 From: "Joshua C. Randall" Date: Sun, 16 Jun 2019 00:03:43 +0000 Subject: [PATCH 04/61] fix reference to link_lib in vcpkg build --- libsqlite3-sys/build.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index 9d24bb271..db8015cba 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -295,7 +295,6 @@ mod build_loadable_extension { // Prints the necessary cargo link commands and returns the path to the header. fn find_sqlite() -> HeaderLocation { let link_lib = "sqlite3"; - println!("cargo:rerun-if-env-changed={}_INCLUDE_DIR", env_prefix()); println!("cargo:rerun-if-env-changed={}_LIB_DIR", env_prefix()); println!("cargo:rerun-if-env-changed={}_STATIC", env_prefix()); @@ -336,8 +335,9 @@ mod build_loadable_extension { #[cfg(all(feature = "vcpkg", target_env = "msvc"))] fn try_vcpkg() -> Option { + let link_lib = "sqlite3"; // See if vcpkg can find it. - if let Ok(mut lib) = vcpkg::Config::new().probe(link_lib()) { + if let Ok(mut lib) = vcpkg::Config::new().probe(link_lib) { if let Some(mut header) = lib.include_paths.pop() { header.push(header_file()); return Some(HeaderLocation::FromPath(header.to_string_lossy().into())); From 955521fa243b56ce74ff7eefd7dfc9b91447c579 Mon Sep 17 00:00:00 2001 From: gwenn Date: Sun, 9 Feb 2020 13:00:05 +0100 Subject: [PATCH 05/61] Remove old bindgens --- libsqlite3-sys/Cargo.toml | 2 - .../bindgen_3.13.0-ext-embed.rs | 10180 -------------- .../bindgen-bindings/bindgen_3.13.0-ext.rs | 10178 -------------- .../bindgen-bindings/bindgen_3.13.0.rs | 4954 ------- .../bindgen_3.26.0-ext-embed.rs | 11140 ---------------- .../bindgen-bindings/bindgen_3.26.0-ext.rs | 11138 --------------- .../bindgen-bindings/bindgen_3.26.0.rs | 5225 -------- libsqlite3-sys/build.rs | 12 +- src/inner_connection.rs | 23 +- src/lib.rs | 9 +- 10 files changed, 28 insertions(+), 52833 deletions(-) delete mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.13.0-ext-embed.rs delete mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.13.0-ext.rs delete mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.13.0.rs delete mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.26.0-ext-embed.rs delete mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.26.0-ext.rs delete mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.26.0.rs diff --git a/libsqlite3-sys/Cargo.toml b/libsqlite3-sys/Cargo.toml index e919c4c20..4638c80de 100644 --- a/libsqlite3-sys/Cargo.toml +++ b/libsqlite3-sys/Cargo.toml @@ -23,9 +23,7 @@ min_sqlite_version_3_6_8 = ["pkg-config", "vcpkg"] min_sqlite_version_3_6_23 = ["pkg-config", "vcpkg"] min_sqlite_version_3_7_7 = ["pkg-config", "vcpkg"] min_sqlite_version_3_7_16 = ["pkg-config", "vcpkg"] -min_sqlite_version_3_13_0 = ["pkg-config", "vcpkg"] min_sqlite_version_3_20_0 = ["pkg-config", "vcpkg"] -min_sqlite_version_3_26_0 = ["pkg-config", "vcpkg"] # Bundle only the bindings file. Note that this does nothing if # `buildtime_bindgen` is enabled. bundled_bindings = [] diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.13.0-ext-embed.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.13.0-ext-embed.rs deleted file mode 100644 index c09e856f7..000000000 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.13.0-ext-embed.rs +++ /dev/null @@ -1,10180 +0,0 @@ -/* automatically generated by rust-bindgen */ - -pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.13.0\0"; -pub const SQLITE_VERSION_NUMBER: i32 = 3013000; -pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = - b"2016-05-18 10:57:30 fc49f556e48970561d7ab6a2f24fdd7d9eb81ff2\0"; -pub const SQLITE_OK: i32 = 0; -pub const SQLITE_ERROR: i32 = 1; -pub const SQLITE_INTERNAL: i32 = 2; -pub const SQLITE_PERM: i32 = 3; -pub const SQLITE_ABORT: i32 = 4; -pub const SQLITE_BUSY: i32 = 5; -pub const SQLITE_LOCKED: i32 = 6; -pub const SQLITE_NOMEM: i32 = 7; -pub const SQLITE_READONLY: i32 = 8; -pub const SQLITE_INTERRUPT: i32 = 9; -pub const SQLITE_IOERR: i32 = 10; -pub const SQLITE_CORRUPT: i32 = 11; -pub const SQLITE_NOTFOUND: i32 = 12; -pub const SQLITE_FULL: i32 = 13; -pub const SQLITE_CANTOPEN: i32 = 14; -pub const SQLITE_PROTOCOL: i32 = 15; -pub const SQLITE_EMPTY: i32 = 16; -pub const SQLITE_SCHEMA: i32 = 17; -pub const SQLITE_TOOBIG: i32 = 18; -pub const SQLITE_CONSTRAINT: i32 = 19; -pub const SQLITE_MISMATCH: i32 = 20; -pub const SQLITE_MISUSE: i32 = 21; -pub const SQLITE_NOLFS: i32 = 22; -pub const SQLITE_AUTH: i32 = 23; -pub const SQLITE_FORMAT: i32 = 24; -pub const SQLITE_RANGE: i32 = 25; -pub const SQLITE_NOTADB: i32 = 26; -pub const SQLITE_NOTICE: i32 = 27; -pub const SQLITE_WARNING: i32 = 28; -pub const SQLITE_ROW: i32 = 100; -pub const SQLITE_DONE: i32 = 101; -pub const SQLITE_IOERR_READ: i32 = 266; -pub const SQLITE_IOERR_SHORT_READ: i32 = 522; -pub const SQLITE_IOERR_WRITE: i32 = 778; -pub const SQLITE_IOERR_FSYNC: i32 = 1034; -pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; -pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; -pub const SQLITE_IOERR_FSTAT: i32 = 1802; -pub const SQLITE_IOERR_UNLOCK: i32 = 2058; -pub const SQLITE_IOERR_RDLOCK: i32 = 2314; -pub const SQLITE_IOERR_DELETE: i32 = 2570; -pub const SQLITE_IOERR_BLOCKED: i32 = 2826; -pub const SQLITE_IOERR_NOMEM: i32 = 3082; -pub const SQLITE_IOERR_ACCESS: i32 = 3338; -pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; -pub const SQLITE_IOERR_LOCK: i32 = 3850; -pub const SQLITE_IOERR_CLOSE: i32 = 4106; -pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; -pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; -pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; -pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; -pub const SQLITE_IOERR_SHMMAP: i32 = 5386; -pub const SQLITE_IOERR_SEEK: i32 = 5642; -pub const SQLITE_IOERR_DELETE_NOENT: i32 = 5898; -pub const SQLITE_IOERR_MMAP: i32 = 6154; -pub const SQLITE_IOERR_GETTEMPPATH: i32 = 6410; -pub const SQLITE_IOERR_CONVPATH: i32 = 6666; -pub const SQLITE_IOERR_VNODE: i32 = 6922; -pub const SQLITE_IOERR_AUTH: i32 = 7178; -pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; -pub const SQLITE_BUSY_RECOVERY: i32 = 261; -pub const SQLITE_BUSY_SNAPSHOT: i32 = 517; -pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; -pub const SQLITE_CANTOPEN_ISDIR: i32 = 526; -pub const SQLITE_CANTOPEN_FULLPATH: i32 = 782; -pub const SQLITE_CANTOPEN_CONVPATH: i32 = 1038; -pub const SQLITE_CORRUPT_VTAB: i32 = 267; -pub const SQLITE_READONLY_RECOVERY: i32 = 264; -pub const SQLITE_READONLY_CANTLOCK: i32 = 520; -pub const SQLITE_READONLY_ROLLBACK: i32 = 776; -pub const SQLITE_READONLY_DBMOVED: i32 = 1032; -pub const SQLITE_ABORT_ROLLBACK: i32 = 516; -pub const SQLITE_CONSTRAINT_CHECK: i32 = 275; -pub const SQLITE_CONSTRAINT_COMMITHOOK: i32 = 531; -pub const SQLITE_CONSTRAINT_FOREIGNKEY: i32 = 787; -pub const SQLITE_CONSTRAINT_FUNCTION: i32 = 1043; -pub const SQLITE_CONSTRAINT_NOTNULL: i32 = 1299; -pub const SQLITE_CONSTRAINT_PRIMARYKEY: i32 = 1555; -pub const SQLITE_CONSTRAINT_TRIGGER: i32 = 1811; -pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067; -pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323; -pub const SQLITE_CONSTRAINT_ROWID: i32 = 2579; -pub const SQLITE_NOTICE_RECOVER_WAL: i32 = 283; -pub const SQLITE_NOTICE_RECOVER_ROLLBACK: i32 = 539; -pub const SQLITE_WARNING_AUTOINDEX: i32 = 284; -pub const SQLITE_AUTH_USER: i32 = 279; -pub const SQLITE_OPEN_READONLY: i32 = 1; -pub const SQLITE_OPEN_READWRITE: i32 = 2; -pub const SQLITE_OPEN_CREATE: i32 = 4; -pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; -pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; -pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; -pub const SQLITE_OPEN_URI: i32 = 64; -pub const SQLITE_OPEN_MEMORY: i32 = 128; -pub const SQLITE_OPEN_MAIN_DB: i32 = 256; -pub const SQLITE_OPEN_TEMP_DB: i32 = 512; -pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; -pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; -pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; -pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; -pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; -pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; -pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; -pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; -pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; -pub const SQLITE_OPEN_WAL: i32 = 524288; -pub const SQLITE_IOCAP_ATOMIC: i32 = 1; -pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; -pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; -pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; -pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; -pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; -pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; -pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; -pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; -pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; -pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; -pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; -pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE: i32 = 4096; -pub const SQLITE_IOCAP_IMMUTABLE: i32 = 8192; -pub const SQLITE_LOCK_NONE: i32 = 0; -pub const SQLITE_LOCK_SHARED: i32 = 1; -pub const SQLITE_LOCK_RESERVED: i32 = 2; -pub const SQLITE_LOCK_PENDING: i32 = 3; -pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; -pub const SQLITE_SYNC_NORMAL: i32 = 2; -pub const SQLITE_SYNC_FULL: i32 = 3; -pub const SQLITE_SYNC_DATAONLY: i32 = 16; -pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; -pub const SQLITE_FCNTL_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_FCNTL_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_FCNTL_LAST_ERRNO: i32 = 4; -pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; -pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; -pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; -pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; -pub const SQLITE_FCNTL_WIN32_AV_RETRY: i32 = 9; -pub const SQLITE_FCNTL_PERSIST_WAL: i32 = 10; -pub const SQLITE_FCNTL_OVERWRITE: i32 = 11; -pub const SQLITE_FCNTL_VFSNAME: i32 = 12; -pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE: i32 = 13; -pub const SQLITE_FCNTL_PRAGMA: i32 = 14; -pub const SQLITE_FCNTL_BUSYHANDLER: i32 = 15; -pub const SQLITE_FCNTL_TEMPFILENAME: i32 = 16; -pub const SQLITE_FCNTL_MMAP_SIZE: i32 = 18; -pub const SQLITE_FCNTL_TRACE: i32 = 19; -pub const SQLITE_FCNTL_HAS_MOVED: i32 = 20; -pub const SQLITE_FCNTL_SYNC: i32 = 21; -pub const SQLITE_FCNTL_COMMIT_PHASETWO: i32 = 22; -pub const SQLITE_FCNTL_WIN32_SET_HANDLE: i32 = 23; -pub const SQLITE_FCNTL_WAL_BLOCK: i32 = 24; -pub const SQLITE_FCNTL_ZIPVFS: i32 = 25; -pub const SQLITE_FCNTL_RBU: i32 = 26; -pub const SQLITE_FCNTL_VFS_POINTER: i32 = 27; -pub const SQLITE_FCNTL_JOURNAL_POINTER: i32 = 28; -pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_LAST_ERRNO: i32 = 4; -pub const SQLITE_ACCESS_EXISTS: i32 = 0; -pub const SQLITE_ACCESS_READWRITE: i32 = 1; -pub const SQLITE_ACCESS_READ: i32 = 2; -pub const SQLITE_SHM_UNLOCK: i32 = 1; -pub const SQLITE_SHM_LOCK: i32 = 2; -pub const SQLITE_SHM_SHARED: i32 = 4; -pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; -pub const SQLITE_SHM_NLOCK: i32 = 8; -pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; -pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; -pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; -pub const SQLITE_CONFIG_MALLOC: i32 = 4; -pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; -pub const SQLITE_CONFIG_SCRATCH: i32 = 6; -pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; -pub const SQLITE_CONFIG_HEAP: i32 = 8; -pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; -pub const SQLITE_CONFIG_MUTEX: i32 = 10; -pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; -pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; -pub const SQLITE_CONFIG_PCACHE: i32 = 14; -pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; -pub const SQLITE_CONFIG_LOG: i32 = 16; -pub const SQLITE_CONFIG_URI: i32 = 17; -pub const SQLITE_CONFIG_PCACHE2: i32 = 18; -pub const SQLITE_CONFIG_GETPCACHE2: i32 = 19; -pub const SQLITE_CONFIG_COVERING_INDEX_SCAN: i32 = 20; -pub const SQLITE_CONFIG_SQLLOG: i32 = 21; -pub const SQLITE_CONFIG_MMAP_SIZE: i32 = 22; -pub const SQLITE_CONFIG_WIN32_HEAPSIZE: i32 = 23; -pub const SQLITE_CONFIG_PCACHE_HDRSZ: i32 = 24; -pub const SQLITE_CONFIG_PMASZ: i32 = 25; -pub const SQLITE_CONFIG_STMTJRNL_SPILL: i32 = 26; -pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; -pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; -pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; -pub const SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: i32 = 1004; -pub const SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: i32 = 1005; -pub const SQLITE_DENY: i32 = 1; -pub const SQLITE_IGNORE: i32 = 2; -pub const SQLITE_CREATE_INDEX: i32 = 1; -pub const SQLITE_CREATE_TABLE: i32 = 2; -pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; -pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; -pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; -pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; -pub const SQLITE_CREATE_TRIGGER: i32 = 7; -pub const SQLITE_CREATE_VIEW: i32 = 8; -pub const SQLITE_DELETE: i32 = 9; -pub const SQLITE_DROP_INDEX: i32 = 10; -pub const SQLITE_DROP_TABLE: i32 = 11; -pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; -pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; -pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; -pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; -pub const SQLITE_DROP_TRIGGER: i32 = 16; -pub const SQLITE_DROP_VIEW: i32 = 17; -pub const SQLITE_INSERT: i32 = 18; -pub const SQLITE_PRAGMA: i32 = 19; -pub const SQLITE_READ: i32 = 20; -pub const SQLITE_SELECT: i32 = 21; -pub const SQLITE_TRANSACTION: i32 = 22; -pub const SQLITE_UPDATE: i32 = 23; -pub const SQLITE_ATTACH: i32 = 24; -pub const SQLITE_DETACH: i32 = 25; -pub const SQLITE_ALTER_TABLE: i32 = 26; -pub const SQLITE_REINDEX: i32 = 27; -pub const SQLITE_ANALYZE: i32 = 28; -pub const SQLITE_CREATE_VTABLE: i32 = 29; -pub const SQLITE_DROP_VTABLE: i32 = 30; -pub const SQLITE_FUNCTION: i32 = 31; -pub const SQLITE_SAVEPOINT: i32 = 32; -pub const SQLITE_COPY: i32 = 0; -pub const SQLITE_RECURSIVE: i32 = 33; -pub const SQLITE_LIMIT_LENGTH: i32 = 0; -pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; -pub const SQLITE_LIMIT_COLUMN: i32 = 2; -pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; -pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; -pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; -pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; -pub const SQLITE_LIMIT_ATTACHED: i32 = 7; -pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; -pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; -pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; -pub const SQLITE_LIMIT_WORKER_THREADS: i32 = 11; -pub const SQLITE_INTEGER: i32 = 1; -pub const SQLITE_FLOAT: i32 = 2; -pub const SQLITE_BLOB: i32 = 4; -pub const SQLITE_NULL: i32 = 5; -pub const SQLITE_TEXT: i32 = 3; -pub const SQLITE3_TEXT: i32 = 3; -pub const SQLITE_UTF8: i32 = 1; -pub const SQLITE_UTF16LE: i32 = 2; -pub const SQLITE_UTF16BE: i32 = 3; -pub const SQLITE_UTF16: i32 = 4; -pub const SQLITE_ANY: i32 = 5; -pub const SQLITE_UTF16_ALIGNED: i32 = 8; -pub const SQLITE_DETERMINISTIC: i32 = 2048; -pub const SQLITE_INDEX_SCAN_UNIQUE: i32 = 1; -pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; -pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; -pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; -pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; -pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; -pub const SQLITE_INDEX_CONSTRAINT_LIKE: i32 = 65; -pub const SQLITE_INDEX_CONSTRAINT_GLOB: i32 = 66; -pub const SQLITE_INDEX_CONSTRAINT_REGEXP: i32 = 67; -pub const SQLITE_MUTEX_FAST: i32 = 0; -pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; -pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; -pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; -pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; -pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; -pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; -pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; -pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; -pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; -pub const SQLITE_MUTEX_STATIC_APP1: i32 = 8; -pub const SQLITE_MUTEX_STATIC_APP2: i32 = 9; -pub const SQLITE_MUTEX_STATIC_APP3: i32 = 10; -pub const SQLITE_MUTEX_STATIC_VFS1: i32 = 11; -pub const SQLITE_MUTEX_STATIC_VFS2: i32 = 12; -pub const SQLITE_MUTEX_STATIC_VFS3: i32 = 13; -pub const SQLITE_TESTCTRL_FIRST: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; -pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; -pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; -pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; -pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; -pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; -pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; -pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; -pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; -pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; -pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; -pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 17; -pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 18; -pub const SQLITE_TESTCTRL_EXPLAIN_STMT: i32 = 19; -pub const SQLITE_TESTCTRL_NEVER_CORRUPT: i32 = 20; -pub const SQLITE_TESTCTRL_VDBE_COVERAGE: i32 = 21; -pub const SQLITE_TESTCTRL_BYTEORDER: i32 = 22; -pub const SQLITE_TESTCTRL_ISINIT: i32 = 23; -pub const SQLITE_TESTCTRL_SORTER_MMAP: i32 = 24; -pub const SQLITE_TESTCTRL_IMPOSTER: i32 = 25; -pub const SQLITE_TESTCTRL_LAST: i32 = 25; -pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; -pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; -pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; -pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; -pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; -pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; -pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; -pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; -pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; -pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; -pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; -pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; -pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; -pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; -pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; -pub const SQLITE_DBSTATUS_CACHE_HIT: i32 = 7; -pub const SQLITE_DBSTATUS_CACHE_MISS: i32 = 8; -pub const SQLITE_DBSTATUS_CACHE_WRITE: i32 = 9; -pub const SQLITE_DBSTATUS_DEFERRED_FKS: i32 = 10; -pub const SQLITE_DBSTATUS_MAX: i32 = 10; -pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; -pub const SQLITE_STMTSTATUS_SORT: i32 = 2; -pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; -pub const SQLITE_STMTSTATUS_VM_STEP: i32 = 4; -pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; -pub const SQLITE_CHECKPOINT_FULL: i32 = 1; -pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; -pub const SQLITE_CHECKPOINT_TRUNCATE: i32 = 3; -pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; -pub const SQLITE_ROLLBACK: i32 = 1; -pub const SQLITE_FAIL: i32 = 3; -pub const SQLITE_REPLACE: i32 = 5; -pub const SQLITE_SCANSTAT_NLOOP: i32 = 0; -pub const SQLITE_SCANSTAT_NVISIT: i32 = 1; -pub const SQLITE_SCANSTAT_EST: i32 = 2; -pub const SQLITE_SCANSTAT_NAME: i32 = 3; -pub const SQLITE_SCANSTAT_EXPLAIN: i32 = 4; -pub const SQLITE_SCANSTAT_SELECTID: i32 = 5; -pub const NOT_WITHIN: i32 = 0; -pub const PARTLY_WITHIN: i32 = 1; -pub const FULLY_WITHIN: i32 = 2; -pub const FTS5_TOKENIZE_QUERY: i32 = 1; -pub const FTS5_TOKENIZE_PREFIX: i32 = 2; -pub const FTS5_TOKENIZE_DOCUMENT: i32 = 4; -pub const FTS5_TOKENIZE_AUX: i32 = 8; -pub const FTS5_TOKEN_COLOCATED: i32 = 1; -pub type va_list = __builtin_va_list; -pub type __gnuc_va_list = __builtin_va_list; -extern "C" { - #[link_name = "\u{1}sqlite3_version"] - pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3 { - _unused: [u8; 0], -} -pub type sqlite_int64 = ::std::os::raw::c_longlong; -pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; -pub type sqlite3_int64 = sqlite_int64; -pub type sqlite3_uint64 = sqlite_uint64; -pub type sqlite3_callback = ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_file { - pub pMethods: *const sqlite3_io_methods, -} -#[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_file)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_file)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_file), - "::", - stringify!(pMethods) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_io_methods { - pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xRead: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *mut ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xWrite: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *const ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pSize: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xUnlock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCheckReservedLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileControl: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - op: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xSectorSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xDeviceCharacteristics: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xShmMap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iPg: ::std::os::raw::c_int, - pgsz: ::std::os::raw::c_int, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xShmLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - offset: ::std::os::raw::c_int, - n: ::std::os::raw::c_int, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xShmBarrier: ::std::option::Option, - pub xShmUnmap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - deleteFlag: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iOfst: sqlite3_int64, - iAmt: ::std::os::raw::c_int, - pp: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xUnfetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iOfst: sqlite3_int64, - p: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_io_methods() { - assert_eq!( - ::std::mem::size_of::(), - 152usize, - concat!("Size of: ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xRead) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xWrite) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnlock) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xCheckReservedLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileControl) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSectorSize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ - as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xDeviceCharacteristics) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmMap) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmBarrier) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmUnmap) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnfetch as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnfetch) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex { - _unused: [u8; 0], -} -pub type sqlite3_syscall_ptr = ::std::option::Option; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vfs { - pub iVersion: ::std::os::raw::c_int, - pub szOsFile: ::std::os::raw::c_int, - pub mxPathname: ::std::os::raw::c_int, - pub pNext: *mut sqlite3_vfs, - pub zName: *const ::std::os::raw::c_char, - pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - pOutFlags: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - syncDir: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xAccess: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - flags: ::std::os::raw::c_int, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFullPathname: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - nOut: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xDlOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zFilename: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void, - >, - pub xDlError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zErrMsg: *mut ::std::os::raw::c_char, - ), - >, - pub xDlSym: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ) -> ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ), - >, - >, - pub xDlClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), - >, - pub xRandomness: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSleep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - microseconds: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTime: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, - >, - pub xGetLastError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTimeInt64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xSetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: sqlite3_syscall_ptr, - ) -> ::std::os::raw::c_int, - >, - pub xGetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> sqlite3_syscall_ptr, - >, - pub xNextSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!( - ::std::mem::size_of::(), - 168usize, - concat!("Size of: ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(szOsFile) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(mxPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(zName) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pAppData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xAccess) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xFullPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlSym) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xRandomness) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSleep) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTime) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetLastError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTimeInt64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xNextSystemCall) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xRoundup: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub pAppData: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!( - ::std::mem::size_of::(), - 64usize, - concat!("Size of: ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xMalloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xFree) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRealloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRoundup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(pAppData) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Mem { - _unused: [u8; 0], -} -pub type sqlite3_value = Mem; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_context { - _unused: [u8; 0], -} -pub type sqlite3_destructor_type = - ::std::option::Option; -extern "C" { - #[link_name = "\u{1}sqlite3_temp_directory"] - pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; -} -extern "C" { - #[link_name = "\u{1}sqlite3_data_directory"] - pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xConnect: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xBestIndex: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: *mut sqlite3_index_info, - ) -> ::std::os::raw::c_int, - >, - pub xDisconnect: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xDestroy: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - ppCursor: *mut *mut sqlite3_vtab_cursor, - ) -> ::std::os::raw::c_int, - >, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xFilter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - idxNum: ::std::os::raw::c_int, - idxStr: *const ::std::os::raw::c_char, - argc: ::std::os::raw::c_int, - argv: *mut *mut sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub xNext: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xEof: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - arg2: *mut sqlite3_context, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - pRowid: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xUpdate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - arg4: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xBegin: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xCommit: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xRollback: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xFindFunction: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - nArg: ::std::os::raw::c_int, - zName: *const ::std::os::raw::c_char, - pxFunc: *mut ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - ppArg: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xRename: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - zNew: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSavepoint: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRelease: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRollbackTo: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!( - ::std::mem::size_of::(), - 184usize, - concat!("Size of: ", stringify!(sqlite3_module)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_module)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xConnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBestIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDisconnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFilter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xEof) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xColumn) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xUpdate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBegin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCommit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollback) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFindFunction) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRename) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSavepoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRelease) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollbackTo) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info { - pub nConstraint: ::std::os::raw::c_int, - pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, - pub nOrderBy: ::std::os::raw::c_int, - pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, - pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, - pub idxNum: ::std::os::raw::c_int, - pub idxStr: *mut ::std::os::raw::c_char, - pub needToFreeIdxStr: ::std::os::raw::c_int, - pub orderByConsumed: ::std::os::raw::c_int, - pub estimatedCost: f64, - pub estimatedRows: sqlite3_int64, - pub idxFlags: ::std::os::raw::c_int, - pub colUsed: sqlite3_uint64, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint { - pub iColumn: ::std::os::raw::c_int, - pub op: ::std::os::raw::c_uchar, - pub usable: ::std::os::raw::c_uchar, - pub iTermOffset: ::std::os::raw::c_int, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).op as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(op) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).usable - as *const _ as usize - }, - 5usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(usable) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iTermOffset - as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iTermOffset) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_orderby { - pub iColumn: ::std::os::raw::c_int, - pub desc: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).desc as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(desc) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint_usage { - pub argvIndex: ::std::os::raw::c_int, - pub omit: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).argvIndex - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(argvIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).omit - as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(omit) - ) - ); -} -#[test] -fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!( - ::std::mem::size_of::(), - 96usize, - concat!("Size of: ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nOrderBy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aOrderBy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraintUsage) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxNum) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(needToFreeIdxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(orderByConsumed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedCost as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedCost) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedRows as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedRows) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxFlags as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxFlags) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).colUsed as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(colUsed) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(pModule) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(nRef) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(zErrMsg) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab_cursor { - pub pVtab: *mut sqlite3_vtab, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab_cursor), - "::", - stringify!(pVtab) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexNotheld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexInit as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnd) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexAlloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexFree as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexFree) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexTry) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexLeave) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexHeld) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexNotheld) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_page { - pub pBuf: *mut ::std::os::raw::c_void, - pub pExtra: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_page() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(sqlite3_pcache_page)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_page)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_page), - "::", - stringify!(pBuf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_page), - "::", - stringify!(pExtra) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods2 { - pub iVersion: ::std::os::raw::c_int, - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - szExtra: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache_page, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut sqlite3_pcache_page, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut sqlite3_pcache_page, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, - pub xShrink: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods2() { - assert_eq!( - ::std::mem::size_of::(), - 104usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iVersion as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDestroy as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xShrink) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods { - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!( - ::std::mem::size_of::(), - 88usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xDestroy) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_backup { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_snapshot { - _unused: [u8; 0], -} -pub type sqlite3_rtree_dbl = f64; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_rtree_geometry { - pub pContext: *mut ::std::os::raw::c_void, - pub nParam: ::std::os::raw::c_int, - pub aParam: *mut sqlite3_rtree_dbl, - pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_rtree_geometry() { - assert_eq!( - ::std::mem::size_of::(), - 40usize, - concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pContext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(nParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(aParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pUser) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(xDelUser) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_rtree_query_info { - pub pContext: *mut ::std::os::raw::c_void, - pub nParam: ::std::os::raw::c_int, - pub aParam: *mut sqlite3_rtree_dbl, - pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, - pub aCoord: *mut sqlite3_rtree_dbl, - pub anQueue: *mut ::std::os::raw::c_uint, - pub nCoord: ::std::os::raw::c_int, - pub iLevel: ::std::os::raw::c_int, - pub mxLevel: ::std::os::raw::c_int, - pub iRowid: sqlite3_int64, - pub rParentScore: sqlite3_rtree_dbl, - pub eParentWithin: ::std::os::raw::c_int, - pub eWithin: ::std::os::raw::c_int, - pub rScore: sqlite3_rtree_dbl, - pub apSqlParam: *mut *mut sqlite3_value, -} -#[test] -fn bindgen_test_layout_sqlite3_rtree_query_info() { - assert_eq!( - ::std::mem::size_of::(), - 112usize, - concat!("Size of: ", stringify!(sqlite3_rtree_query_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_rtree_query_info)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).pContext as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(pContext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(nParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(aParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(pUser) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDelUser as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(xDelUser) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aCoord as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(aCoord) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).anQueue as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(anQueue) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nCoord as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(nCoord) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iLevel as *const _ as usize }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(iLevel) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mxLevel as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(mxLevel) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iRowid as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(iRowid) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rParentScore as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(rParentScore) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).eParentWithin as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(eParentWithin) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).eWithin as *const _ as usize - }, - 92usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(eWithin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).rScore as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(rScore) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).apSqlParam as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(apSqlParam) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5Context { - _unused: [u8; 0], -} -pub type fts5_extension_function = ::std::option::Option< - unsafe extern "C" fn( - pApi: *const Fts5ExtensionApi, - pFts: *mut Fts5Context, - pCtx: *mut sqlite3_context, - nVal: ::std::os::raw::c_int, - apVal: *mut *mut sqlite3_value, - ), ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5PhraseIter { - pub a: *const ::std::os::raw::c_uchar, - pub b: *const ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_Fts5PhraseIter() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(Fts5PhraseIter)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Fts5PhraseIter)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).a as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Fts5PhraseIter), - "::", - stringify!(a) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).b as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Fts5PhraseIter), - "::", - stringify!(b) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5ExtensionApi { - pub iVersion: ::std::os::raw::c_int, - pub xUserData: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> *mut ::std::os::raw::c_void, - >, - pub xColumnCount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, - >, - pub xRowCount: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pnRow: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xColumnTotalSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pnToken: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTokenize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pText: *const ::std::os::raw::c_char, - nText: ::std::os::raw::c_int, - pCtx: *mut ::std::os::raw::c_void, - xToken: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, - arg6: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseCount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, - >, - pub xPhraseSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xInstCount: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pnInst: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xInst: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iIdx: ::std::os::raw::c_int, - piPhrase: *mut ::std::os::raw::c_int, - piCol: *mut ::std::os::raw::c_int, - piOff: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: - ::std::option::Option sqlite3_int64>, - pub xColumnText: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pz: *mut *const ::std::os::raw::c_char, - pn: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xColumnSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pnToken: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xQueryPhrase: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - pUserData: *mut ::std::os::raw::c_void, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const Fts5ExtensionApi, - arg2: *mut Fts5Context, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub xSetAuxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pAux: *mut ::std::os::raw::c_void, - xDelete: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub xGetAuxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - bClear: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xPhraseFirst: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - arg2: *mut Fts5PhraseIter, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseNext: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - arg2: *mut Fts5PhraseIter, - piCol: *mut ::std::os::raw::c_int, - piOff: *mut ::std::os::raw::c_int, - ), - >, - pub xPhraseFirstColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - arg2: *mut Fts5PhraseIter, - arg3: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseNextColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - arg2: *mut Fts5PhraseIter, - piCol: *mut ::std::os::raw::c_int, - ), - >, -} -#[test] -fn bindgen_test_layout_Fts5ExtensionApi() { - assert_eq!( - ::std::mem::size_of::(), - 160usize, - concat!("Size of: ", stringify!(Fts5ExtensionApi)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Fts5ExtensionApi)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUserData as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xUserData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnCount as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowCount as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xRowCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xColumnTotalSize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnTotalSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xTokenize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseCount as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseSize as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInstCount as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xInstCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInst as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xInst) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnText as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnText) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnSize as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xQueryPhrase as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xQueryPhrase) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSetAuxdata as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xSetAuxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetAuxdata as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xGetAuxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseFirst as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseFirst) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseNext as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseNext) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPhraseFirstColumn as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseFirstColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPhraseNextColumn as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseNextColumn) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5Tokenizer { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct fts5_tokenizer { - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - azArg: *mut *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ppOut: *mut *mut Fts5Tokenizer, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option, - pub xTokenize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Tokenizer, - pCtx: *mut ::std::os::raw::c_void, - flags: ::std::os::raw::c_int, - pText: *const ::std::os::raw::c_char, - nText: ::std::os::raw::c_int, - xToken: ::std::option::Option< - unsafe extern "C" fn( - pCtx: *mut ::std::os::raw::c_void, - tflags: ::std::os::raw::c_int, - pToken: *const ::std::os::raw::c_char, - nToken: ::std::os::raw::c_int, - iStart: ::std::os::raw::c_int, - iEnd: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_fts5_tokenizer() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(fts5_tokenizer)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(fts5_tokenizer)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xTokenize) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct fts5_api { - pub iVersion: ::std::os::raw::c_int, - pub xCreateTokenizer: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - pContext: *mut ::std::os::raw::c_void, - pTokenizer: *mut fts5_tokenizer, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub xFindTokenizer: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - ppContext: *mut *mut ::std::os::raw::c_void, - pTokenizer: *mut fts5_tokenizer, - ) -> ::std::os::raw::c_int, - >, - pub xCreateFunction: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - pContext: *mut ::std::os::raw::c_void, - xFunction: fts5_extension_function, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_fts5_api() { - assert_eq!( - ::std::mem::size_of::(), - 32usize, - concat!("Size of: ", stringify!(fts5_api)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(fts5_api)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreateTokenizer as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xCreateTokenizer) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindTokenizer as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xFindTokenizer) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreateFunction as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xCreateFunction) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_api_routines { - pub aggregate_context: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub aggregate_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, - >, - pub bind_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_double: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, - ) -> ::std::os::raw::c_int, - >, - pub bind_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_int64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, - ) -> ::std::os::raw::c_int, - >, - pub bind_null: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub bind_parameter_index: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub bind_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub busy_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub busy_timeout: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub changes: - ::std::option::Option ::std::os::raw::c_int>, - pub close: - ::std::option::Option ::std::os::raw::c_int>, - pub collation_needed: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub collation_needed16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub column_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_bytes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_bytes16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub column_database_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_database_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_decltype: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_decltype16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_double: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, - >, - pub column_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_int64: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, - >, - pub column_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_origin_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_origin_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_table_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_table_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_uchar, - >, - pub column_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_type: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *mut sqlite3_value, - >, - pub commit_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub complete: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, - pub complete16: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub create_collation: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_collation16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_function16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_module: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub data_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub db_handle: - ::std::option::Option *mut sqlite3>, - pub declare_vtab: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub enable_shared_cache: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub errcode: - ::std::option::Option ::std::os::raw::c_int>, - pub errmsg: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, - >, - pub errmsg16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, - >, - pub exec: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub expired: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub finalize: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub free: ::std::option::Option, - pub free_table: - ::std::option::Option, - pub get_autocommit: - ::std::option::Option ::std::os::raw::c_int>, - pub get_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub get_table: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub global_recover: ::std::option::Option ::std::os::raw::c_int>, - pub interruptx: ::std::option::Option, - pub last_insert_rowid: - ::std::option::Option sqlite_int64>, - pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, - pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, - pub malloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub mprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub open16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub prepare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub profile: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub progress_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, - ), - >, - pub realloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub reset: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub result_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_double: - ::std::option::Option, - pub result_error: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_error16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_int64: - ::std::option::Option, - pub result_null: ::std::option::Option, - pub result_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16be: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16le: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_value: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), - >, - pub rollback_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub set_authorizer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub set_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, - ), - >, - pub snprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub step: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub table_column_metadata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub thread_cleanup: ::std::option::Option, - pub total_changes: - ::std::option::Option ::std::os::raw::c_int>, - pub trace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub transfer_bindings: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, - ) -> ::std::os::raw::c_int, - >, - pub update_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub user_data: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, - >, - pub value_blob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_bytes16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_double: ::std::option::Option f64>, - pub value_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_int64: - ::std::option::Option sqlite_int64>, - pub value_numeric_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_text: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, - >, - pub value_text16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16be: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16le: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub vmprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char, - >, - pub overload_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub prepare_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub clear_bindings: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub create_module_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_zeroblob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_close: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, - ) -> ::std::os::raw::c_int, - >, - pub blob_read: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_write: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub create_collation_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub file_control: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub memory_highwater: - ::std::option::Option sqlite3_int64>, - pub memory_used: ::std::option::Option sqlite3_int64>, - pub mutex_alloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub mutex_enter: ::std::option::Option, - pub mutex_free: ::std::option::Option, - pub mutex_leave: ::std::option::Option, - pub mutex_try: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub open_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub release_memory: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub result_error_nomem: ::std::option::Option, - pub result_error_toobig: - ::std::option::Option, - pub sleep: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub soft_heap_limit: ::std::option::Option, - pub vfs_find: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, - >, - pub vfs_register: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub vfs_unregister: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, - >, - pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, - pub result_zeroblob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_error_code: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub test_control: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, - >, - pub randomness: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), - >, - pub context_db_handle: - ::std::option::Option *mut sqlite3>, - pub extended_result_codes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub limit: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub next_stmt: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, - >, - pub sql: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, - >, - pub status: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub backup_finish: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_init: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut sqlite3, - arg4: *const ::std::os::raw::c_char, - ) -> *mut sqlite3_backup, - >, - pub backup_pagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_remaining: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_step: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_backup, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub compileoption_get: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, - >, - pub compileoption_used: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, - pub create_function_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub db_config: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int, - >, - pub db_mutex: - ::std::option::Option *mut sqlite3_mutex>, - pub db_status: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub extended_errcode: - ::std::option::Option ::std::os::raw::c_int>, - pub log: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char, ...), - >, - pub soft_heap_limit64: - ::std::option::Option sqlite3_int64>, - pub sourceid: ::std::option::Option *const ::std::os::raw::c_char>, - pub stmt_status: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub strnicmp: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub unlock_notify: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub wal_autocheckpoint: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub wal_checkpoint: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub wal_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub blob_reopen: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob, arg2: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub vtab_config: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int, - >, - pub vtab_on_conflict: - ::std::option::Option ::std::os::raw::c_int>, - pub close_v2: - ::std::option::Option ::std::os::raw::c_int>, - pub db_filename: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, - pub db_readonly: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub db_release_memory: - ::std::option::Option ::std::os::raw::c_int>, - pub errstr: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, - >, - pub stmt_busy: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub stmt_readonly: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub stricmp: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub uri_boolean: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub uri_int64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_int64, - ) -> sqlite3_int64, - >, - pub uri_parameter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, - pub vsnprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char, - >, - pub wal_checkpoint_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub auto_extension: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_blob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_text64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - arg6: ::std::os::raw::c_uchar, - ) -> ::std::os::raw::c_int, - >, - pub cancel_auto_extension: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub load_extension: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub malloc64: ::std::option::Option< - unsafe extern "C" fn(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void, - >, - pub msize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64, - >, - pub realloc64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: sqlite3_uint64, - ) -> *mut ::std::os::raw::c_void, - >, - pub reset_auto_extension: ::std::option::Option, - pub result_blob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - ), - >, - pub result_text64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - arg5: ::std::os::raw::c_uchar, - ), - >, - pub strglob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub value_dup: ::std::option::Option< - unsafe extern "C" fn(arg1: *const sqlite3_value) -> *mut sqlite3_value, - >, - pub value_free: ::std::option::Option, - pub result_zeroblob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: sqlite3_uint64, - ) -> ::std::os::raw::c_int, - >, - pub bind_zeroblob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_uint64, - ) -> ::std::os::raw::c_int, - >, - pub value_subtype: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint, - >, - pub result_subtype: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint), - >, - pub status64: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut sqlite3_int64, - arg3: *mut sqlite3_int64, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub strlike: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_uint, - ) -> ::std::os::raw::c_int, - >, - pub db_cacheflush: - ::std::option::Option ::std::os::raw::c_int>, - pub system_errno: - ::std::option::Option ::std::os::raw::c_int>, -} -#[test] -fn bindgen_test_layout_sqlite3_api_routines() { - assert_eq!( - ::std::mem::size_of::(), - 1712usize, - concat!("Size of: ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_context as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_context) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_count as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_double as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_count as *const _ - as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_index as *const _ - as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_index) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_name as *const _ - as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_text16 as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_handler as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_handler) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_timeout as *const _ as usize - }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_timeout) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(close) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed as *const _ as usize - }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_blob as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes as *const _ as usize - }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize - }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_count as *const _ as usize - }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name as *const _ - as usize - }, - 184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name16 as *const _ - as usize - }, - 192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype as *const _ as usize - }, - 200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize - }, - 208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_double as *const _ as usize - }, - 216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, - 224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_int64 as *const _ as usize - }, - 232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name as *const _ as usize - }, - 240usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name16 as *const _ as usize - }, - 248usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name as *const _ as usize - }, - 256usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name16 as *const _ - as usize - }, - 264usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name as *const _ as usize - }, - 272usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name16 as *const _ - as usize - }, - 280usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text as *const _ as usize - }, - 288usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text16 as *const _ as usize - }, - 296usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_type as *const _ as usize - }, - 304usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_type) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_value as *const _ as usize - }, - 312usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).commit_hook as *const _ as usize - }, - 320usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(commit_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, - 328usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, - 336usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation as *const _ as usize - }, - 344usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation16 as *const _ as usize - }, - 352usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function as *const _ as usize - }, - 360usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function16 as *const _ as usize - }, - 368usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module as *const _ as usize - }, - 376usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, - 384usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(data_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, - 392usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).declare_vtab as *const _ as usize - }, - 400usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(declare_vtab) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).enable_shared_cache as *const _ - as usize - }, - 408usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(enable_shared_cache) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, - 416usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, - 424usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, - 432usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, - 440usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(exec) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, - 448usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(expired) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, - 456usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(finalize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, - 464usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, - 472usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_autocommit as *const _ as usize - }, - 480usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_autocommit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_auxdata as *const _ as usize - }, - 488usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, - 496usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).global_recover as *const _ as usize - }, - 504usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(global_recover) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, - 512usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(interruptx) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize - }, - 520usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(last_insert_rowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, - 528usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).libversion_number as *const _ as usize - }, - 536usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion_number) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, - 544usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(malloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, - 552usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, - 560usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, - 568usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, - 576usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, - 584usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, - 592usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(profile) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).progress_handler as *const _ as usize - }, - 600usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(progress_handler) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, - 608usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(realloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, - 616usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(reset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_blob as *const _ as usize - }, - 624usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_double as *const _ as usize - }, - 632usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_double) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error as *const _ as usize - }, - 640usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error16 as *const _ as usize - }, - 648usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, - 656usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_int64 as *const _ as usize - }, - 664usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_null as *const _ as usize - }, - 672usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text as *const _ as usize - }, - 680usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16 as *const _ as usize - }, - 688usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16be as *const _ as usize - }, - 696usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16le as *const _ as usize - }, - 704usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16le) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_value as *const _ as usize - }, - 712usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rollback_hook as *const _ as usize - }, - 720usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(rollback_hook) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_authorizer as *const _ as usize - }, - 728usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_authorizer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_auxdata as *const _ as usize - }, - 736usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).snprintf as *const _ as usize }, - 744usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(snprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, - 752usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(step) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).table_column_metadata as *const _ - as usize - }, - 760usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(table_column_metadata) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize - }, - 768usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(thread_cleanup) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).total_changes as *const _ as usize - }, - 776usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(total_changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, - 784usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(trace) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize - }, - 792usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(transfer_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).update_hook as *const _ as usize - }, - 800usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(update_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, - 808usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(user_data) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, - 816usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes as *const _ as usize - }, - 824usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize - }, - 832usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_double as *const _ as usize - }, - 840usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, - 848usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_int64 as *const _ as usize - }, - 856usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize - }, - 864usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_numeric_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, - 872usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16 as *const _ as usize - }, - 880usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16be as *const _ as usize - }, - 888usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16le as *const _ as usize - }, - 896usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16le) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, - 904usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, - 912usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vmprintf) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).overload_function as *const _ as usize - }, - 920usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(overload_function) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, - 928usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize - }, - 936usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).clear_bindings as *const _ as usize - }, - 944usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(clear_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize - }, - 952usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize - }, - 960usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_zeroblob) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, - 968usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_bytes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, - 976usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_close) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, - 984usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, - 992usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_read) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, - 1000usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_write) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation_v2 as *const _ - as usize - }, - 1008usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).file_control as *const _ as usize - }, - 1016usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(file_control) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_highwater as *const _ as usize - }, - 1024usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_highwater) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_used as *const _ as usize - }, - 1032usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_used) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize - }, - 1040usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_alloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_enter as *const _ as usize - }, - 1048usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_enter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, - 1056usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_free) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_leave as *const _ as usize - }, - 1064usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_leave) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, - 1072usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_try) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, - 1080usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).release_memory as *const _ as usize - }, - 1088usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(release_memory) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize - }, - 1096usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_nomem) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_toobig as *const _ - as usize - }, - 1104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_toobig) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, - 1112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sleep) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize - }, - 1120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(soft_heap_limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, - 1128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_find) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_register as *const _ as usize - }, - 1136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_register) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize - }, - 1144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_unregister) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize - }, - 1152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(xthreadsafe) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize - }, - 1160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_zeroblob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_code as *const _ as usize - }, - 1168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_code) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).test_control as *const _ as usize - }, - 1176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(test_control) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, - 1184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(randomness) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).context_db_handle as *const _ as usize - }, - 1192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(context_db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).extended_result_codes as *const _ - as usize - }, - 1200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(extended_result_codes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, - 1208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, - 1216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(next_stmt) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, - 1224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sql) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, - 1232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(status) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_finish as *const _ as usize - }, - 1240usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_finish) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_init as *const _ as usize - }, - 1248usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_init) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_pagecount as *const _ as usize - }, - 1256usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_pagecount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_remaining as *const _ as usize - }, - 1264usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_remaining) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_step as *const _ as usize - }, - 1272usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_step) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).compileoption_get as *const _ as usize - }, - 1280usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(compileoption_get) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).compileoption_used as *const _ as usize - }, - 1288usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(compileoption_used) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function_v2 as *const _ as usize - }, - 1296usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function_v2) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_config as *const _ as usize }, - 1304usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_config) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_mutex as *const _ as usize }, - 1312usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_mutex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_status as *const _ as usize }, - 1320usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_status) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).extended_errcode as *const _ as usize - }, - 1328usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(extended_errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).log as *const _ as usize }, - 1336usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(log) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).soft_heap_limit64 as *const _ as usize - }, - 1344usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(soft_heap_limit64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sourceid as *const _ as usize }, - 1352usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sourceid) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stmt_status as *const _ as usize - }, - 1360usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_status) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).strnicmp as *const _ as usize }, - 1368usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(strnicmp) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).unlock_notify as *const _ as usize - }, - 1376usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(unlock_notify) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_autocheckpoint as *const _ as usize - }, - 1384usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_autocheckpoint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_checkpoint as *const _ as usize - }, - 1392usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_checkpoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).wal_hook as *const _ as usize }, - 1400usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_hook) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).blob_reopen as *const _ as usize - }, - 1408usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_reopen) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtab_config as *const _ as usize - }, - 1416usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vtab_config) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtab_on_conflict as *const _ as usize - }, - 1424usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vtab_on_conflict) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).close_v2 as *const _ as usize }, - 1432usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(close_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_filename as *const _ as usize - }, - 1440usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_filename) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_readonly as *const _ as usize - }, - 1448usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_readonly) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_release_memory as *const _ as usize - }, - 1456usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_release_memory) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errstr as *const _ as usize }, - 1464usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errstr) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).stmt_busy as *const _ as usize }, - 1472usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_busy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stmt_readonly as *const _ as usize - }, - 1480usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_readonly) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).stricmp as *const _ as usize }, - 1488usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stricmp) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).uri_boolean as *const _ as usize - }, - 1496usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(uri_boolean) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).uri_int64 as *const _ as usize }, - 1504usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(uri_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).uri_parameter as *const _ as usize - }, - 1512usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(uri_parameter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vsnprintf as *const _ as usize }, - 1520usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vsnprintf) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_checkpoint_v2 as *const _ as usize - }, - 1528usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_checkpoint_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).auto_extension as *const _ as usize - }, - 1536usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(auto_extension) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_blob64 as *const _ as usize - }, - 1544usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_blob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_text64 as *const _ as usize - }, - 1552usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).cancel_auto_extension as *const _ - as usize - }, - 1560usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(cancel_auto_extension) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).load_extension as *const _ as usize - }, - 1568usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(load_extension) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).malloc64 as *const _ as usize }, - 1576usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(malloc64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).msize as *const _ as usize }, - 1584usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(msize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).realloc64 as *const _ as usize }, - 1592usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(realloc64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).reset_auto_extension as *const _ - as usize - }, - 1600usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(reset_auto_extension) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_blob64 as *const _ as usize - }, - 1608usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_blob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text64 as *const _ as usize - }, - 1616usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).strglob as *const _ as usize }, - 1624usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(strglob) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_dup as *const _ as usize }, - 1632usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_dup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_free as *const _ as usize }, - 1640usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_free) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_zeroblob64 as *const _ as usize - }, - 1648usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_zeroblob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_zeroblob64 as *const _ as usize - }, - 1656usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_zeroblob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_subtype as *const _ as usize - }, - 1664usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_subtype) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_subtype as *const _ as usize - }, - 1672usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_subtype) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).status64 as *const _ as usize }, - 1680usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(status64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).strlike as *const _ as usize }, - 1688usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(strlike) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_cacheflush as *const _ as usize - }, - 1696usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_cacheflush) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).system_errno as *const _ as usize - }, - 1704usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(system_errno) - ) - ); -} -pub type __builtin_va_list = [__va_list_tag; 1usize]; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct __va_list_tag { - pub gp_offset: ::std::os::raw::c_uint, - pub fp_offset: ::std::os::raw::c_uint, - pub overflow_arg_area: *mut ::std::os::raw::c_void, - pub reg_save_area: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout___va_list_tag() { - assert_eq!( - ::std::mem::size_of::<__va_list_tag>(), - 24usize, - concat!("Size of: ", stringify!(__va_list_tag)) - ); - assert_eq!( - ::std::mem::align_of::<__va_list_tag>(), - 8usize, - concat!("Alignment of ", stringify!(__va_list_tag)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(gp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(fp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(overflow_arg_area) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(reg_save_area) - ) - ); -} - -// bindings were built with loadable_extension_embedded: -// define sqlite3_api as an extern since this code will be embedded -// within a loadable extension that defines and exports this itself -extern "C" { - #[no_mangle] - pub static mut sqlite3_api: *mut sqlite3_api_routines; -} - -// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) - -pub unsafe fn sqlite3_aggregate_context( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_context.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_context", - " function" - )))(arg1, nBytes) -} - -pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_blob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_blob", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_double( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_double", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_null( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_null", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_parameter_index( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_index.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_index", - " function" - )))(arg1, zName) -} - -pub unsafe fn sqlite3_bind_parameter_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_text( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_text16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_bind_value( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_value", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_handler( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_handler", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_timeout( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_timeout.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_timeout", - " function" - )))(arg1, ms) -} - -pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_collation_needed( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_collation_needed16( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_column_blob( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_blob", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_column_database_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_database_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_decltype( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype", - " function" - )))(arg1, i) -} - -pub unsafe fn sqlite3_column_decltype16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_double", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int64( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int64", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_text( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_text16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_type( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_type", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_value( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_value", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_commit_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).commit_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "commit_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete16", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_create_collation( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_collation16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_function( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_function16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function16", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_module( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).data_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "data_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_declare_vtab( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).declare_vtab.expect(stringify!( - "sqlite3_api contains null pointer for ", - "declare_vtab", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).enable_shared_cache.expect(stringify!( - "sqlite3_api contains null pointer for ", - "enable_shared_cache", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errcode", - " function" - )))(db) -} - -pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_exec( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).exec.expect(stringify!( - "sqlite3_api contains null pointer for ", - "exec", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).expired.expect(stringify!( - "sqlite3_api contains null pointer for ", - "expired", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).finalize.expect(stringify!( - "sqlite3_api contains null pointer for ", - "finalize", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free_table", - " function" - )))(result) -} - -pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_autocommit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_autocommit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_get_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_auxdata", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_get_table( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_table", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).global_recover.expect(stringify!( - "sqlite3_api contains null pointer for ", - "global_recover", - " function" - )))() -} - -pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).interruptx.expect(stringify!( - "sqlite3_api contains null pointer for ", - "interruptx", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).last_insert_rowid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "last_insert_rowid", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion", - " function" - )))() -} - -pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion_number.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion_number", - " function" - )))() -} - -pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).malloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "malloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mprintf( - arg1: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mprintf", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_open( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_open16( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_prepare( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_profile( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).profile.expect(stringify!( - "sqlite3_api contains null pointer for ", - "profile", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_progress_handler( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).progress_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "progress_handler", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_realloc( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).realloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "realloc", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).reset.expect(stringify!( - "sqlite3_api contains null pointer for ", - "reset", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_result_blob( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_blob", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_double", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_error16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_null", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_text( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16be( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16be", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16le( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16le", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_value", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_rollback_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).rollback_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "rollback_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_authorizer( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_authorizer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_authorizer", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_auxdata", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_snprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).snprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "snprintf", - " function" - )))(arg1, arg2, arg3, vararg1) -} - -pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).step.expect(stringify!( - "sqlite3_api contains null pointer for ", - "step", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_table_column_metadata( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).table_column_metadata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "table_column_metadata", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) -} - -pub unsafe fn sqlite3_thread_cleanup() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).thread_cleanup.expect(stringify!( - "sqlite3_api contains null pointer for ", - "thread_cleanup", - " function" - )))() -} - -pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).total_changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "total_changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_trace( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).trace.expect(stringify!( - "sqlite3_api contains null pointer for ", - "trace", - " function" - )))(arg1, xTrace, arg2) -} - -pub unsafe fn sqlite3_transfer_bindings( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).transfer_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "transfer_bindings", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_update_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).update_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "update_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).user_data.expect(stringify!( - "sqlite3_api contains null pointer for ", - "user_data", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_blob", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_double", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_numeric_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_numeric_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16be", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16le", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vmprintf( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vmprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vmprintf", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_overload_function( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).overload_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "overload_function", - " function" - )))(arg1, zFuncName, nArg) -} - -pub unsafe fn sqlite3_prepare_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).clear_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "clear_bindings", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_module_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module_v2", - " function" - )))(arg1, arg2, arg3, arg4, xDestroy) -} - -pub unsafe fn sqlite3_bind_zeroblob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_zeroblob", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_open( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_open", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) -} - -pub unsafe fn sqlite3_blob_read( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_read.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_read", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_blob_write( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_write.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_write", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_create_collation_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_file_control( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).file_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "file_control", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_highwater.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_highwater", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_used.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_used", - " function" - )))() -} - -pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_alloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_alloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_enter.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_enter", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_leave.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_leave", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_try.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_try", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_open_v2( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open_v2", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).release_memory.expect(stringify!( - "sqlite3_api contains null pointer for ", - "release_memory", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_nomem.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_nomem", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_toobig.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_toobig", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sleep.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sleep", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).soft_heap_limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "soft_heap_limit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_find.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_find", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_register( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_register.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_register", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_unregister.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_unregister", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).xthreadsafe.expect(stringify!( - "sqlite3_api contains null pointer for ", - "xthreadsafe", - " function" - )))() -} - -pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_zeroblob", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_code.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_code", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_test_control( - arg1: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).test_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "test_control", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).randomness.expect(stringify!( - "sqlite3_api contains null pointer for ", - "randomness", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).context_db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "context_db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_extended_result_codes( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).extended_result_codes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "extended_result_codes", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_limit( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "limit", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).next_stmt.expect(stringify!( - "sqlite3_api contains null pointer for ", - "next_stmt", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sql.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sql", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_status( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "status", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_finish.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_finish", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_init( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut sqlite3, - arg4: *const ::std::os::raw::c_char, -) -> *mut sqlite3_backup { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_init.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_init", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_pagecount.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_pagecount", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_remaining.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_remaining", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_step( - arg1: *mut sqlite3_backup, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_step.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_step", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_compileoption_get( - arg1: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).compileoption_get.expect(stringify!( - "sqlite3_api contains null pointer for ", - "compileoption_get", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_compileoption_used( - arg1: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).compileoption_used.expect(stringify!( - "sqlite3_api contains null pointer for ", - "compileoption_used", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_function_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal, xDestroy) -} - -pub unsafe fn sqlite3_db_config( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, - vararg2: &mut i32, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_config.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_config", - " function" - )))(arg1, arg2, vararg1, vararg2) -} - -pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_mutex.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_mutex", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_db_status( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_status", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).extended_errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "extended_errcode", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_log( - arg1: ::std::os::raw::c_int, - arg2: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).log.expect(stringify!( - "sqlite3_api contains null pointer for ", - "log", - " function" - )))(arg1, arg2, vararg1) -} - -pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).soft_heap_limit64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "soft_heap_limit64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sourceid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sourceid", - " function" - )))() -} - -pub unsafe fn sqlite3_stmt_status( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_status", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_strnicmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).strnicmp.expect(stringify!( - "sqlite3_api contains null pointer for ", - "strnicmp", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_unlock_notify( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int), - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).unlock_notify.expect(stringify!( - "sqlite3_api contains null pointer for ", - "unlock_notify", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_wal_autocheckpoint( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_autocheckpoint", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_wal_checkpoint( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_checkpoint.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_checkpoint", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_wal_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_blob_reopen( - arg1: *mut sqlite3_blob, - arg2: sqlite3_int64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_reopen.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_reopen", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vtab_config( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vtab_config.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vtab_config", - " function" - )))(arg1, op, vararg1) -} - -pub unsafe fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vtab_on_conflict.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vtab_on_conflict", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "close_v2", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_db_filename( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_filename.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_filename", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_db_readonly( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_readonly.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_readonly", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_release_memory.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_release_memory", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errstr.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errstr", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_busy.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_busy", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_stmt_readonly(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_readonly.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_readonly", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_stricmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stricmp.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stricmp", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_uri_boolean( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).uri_boolean.expect(stringify!( - "sqlite3_api contains null pointer for ", - "uri_boolean", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_uri_int64( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_int64, -) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).uri_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "uri_int64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_uri_parameter( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).uri_parameter.expect(stringify!( - "sqlite3_api contains null pointer for ", - "uri_parameter", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vsnprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut __va_list_tag, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vsnprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vsnprintf", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_wal_checkpoint_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_checkpoint_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_checkpoint_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_auto_extension( - arg1: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).auto_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "auto_extension", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_blob64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_blob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_blob64", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_bind_text64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - arg6: ::std::os::raw::c_uchar, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text64", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_cancel_auto_extension( - arg1: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).cancel_auto_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "cancel_auto_extension", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_load_extension( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).load_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "load_extension", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_malloc64(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).malloc64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "malloc64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_msize(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).msize.expect(stringify!( - "sqlite3_api contains null pointer for ", - "msize", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_realloc64( - arg1: *mut ::std::os::raw::c_void, - arg2: sqlite3_uint64, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).realloc64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "realloc64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_reset_auto_extension() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).reset_auto_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "reset_auto_extension", - " function" - )))() -} - -pub unsafe fn sqlite3_result_blob64( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_blob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_blob64", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text64( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - arg5: ::std::os::raw::c_uchar, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text64", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_strglob( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).strglob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "strglob", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_value_dup(arg1: *const sqlite3_value) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_dup.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_dup", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_free(arg1: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_zeroblob64( - arg1: *mut sqlite3_context, - arg2: sqlite3_uint64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_zeroblob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_zeroblob64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_zeroblob64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_uint64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_zeroblob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_zeroblob64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_value_subtype(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_subtype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_subtype", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_subtype(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_subtype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_subtype", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_status64( - arg1: ::std::os::raw::c_int, - arg2: *mut sqlite3_int64, - arg3: *mut sqlite3_int64, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).status64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "status64", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_strlike( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_uint, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).strlike.expect(stringify!( - "sqlite3_api contains null pointer for ", - "strlike", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_db_cacheflush(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_cacheflush.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_cacheflush", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_system_errno(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).system_errno.expect(stringify!( - "sqlite3_api contains null pointer for ", - "system_errno", - " function" - )))(arg1) -} diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.13.0-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.13.0-ext.rs deleted file mode 100644 index a3e11da90..000000000 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.13.0-ext.rs +++ /dev/null @@ -1,10178 +0,0 @@ -/* automatically generated by rust-bindgen */ - -pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.13.0\0"; -pub const SQLITE_VERSION_NUMBER: i32 = 3013000; -pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = - b"2016-05-18 10:57:30 fc49f556e48970561d7ab6a2f24fdd7d9eb81ff2\0"; -pub const SQLITE_OK: i32 = 0; -pub const SQLITE_ERROR: i32 = 1; -pub const SQLITE_INTERNAL: i32 = 2; -pub const SQLITE_PERM: i32 = 3; -pub const SQLITE_ABORT: i32 = 4; -pub const SQLITE_BUSY: i32 = 5; -pub const SQLITE_LOCKED: i32 = 6; -pub const SQLITE_NOMEM: i32 = 7; -pub const SQLITE_READONLY: i32 = 8; -pub const SQLITE_INTERRUPT: i32 = 9; -pub const SQLITE_IOERR: i32 = 10; -pub const SQLITE_CORRUPT: i32 = 11; -pub const SQLITE_NOTFOUND: i32 = 12; -pub const SQLITE_FULL: i32 = 13; -pub const SQLITE_CANTOPEN: i32 = 14; -pub const SQLITE_PROTOCOL: i32 = 15; -pub const SQLITE_EMPTY: i32 = 16; -pub const SQLITE_SCHEMA: i32 = 17; -pub const SQLITE_TOOBIG: i32 = 18; -pub const SQLITE_CONSTRAINT: i32 = 19; -pub const SQLITE_MISMATCH: i32 = 20; -pub const SQLITE_MISUSE: i32 = 21; -pub const SQLITE_NOLFS: i32 = 22; -pub const SQLITE_AUTH: i32 = 23; -pub const SQLITE_FORMAT: i32 = 24; -pub const SQLITE_RANGE: i32 = 25; -pub const SQLITE_NOTADB: i32 = 26; -pub const SQLITE_NOTICE: i32 = 27; -pub const SQLITE_WARNING: i32 = 28; -pub const SQLITE_ROW: i32 = 100; -pub const SQLITE_DONE: i32 = 101; -pub const SQLITE_IOERR_READ: i32 = 266; -pub const SQLITE_IOERR_SHORT_READ: i32 = 522; -pub const SQLITE_IOERR_WRITE: i32 = 778; -pub const SQLITE_IOERR_FSYNC: i32 = 1034; -pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; -pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; -pub const SQLITE_IOERR_FSTAT: i32 = 1802; -pub const SQLITE_IOERR_UNLOCK: i32 = 2058; -pub const SQLITE_IOERR_RDLOCK: i32 = 2314; -pub const SQLITE_IOERR_DELETE: i32 = 2570; -pub const SQLITE_IOERR_BLOCKED: i32 = 2826; -pub const SQLITE_IOERR_NOMEM: i32 = 3082; -pub const SQLITE_IOERR_ACCESS: i32 = 3338; -pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; -pub const SQLITE_IOERR_LOCK: i32 = 3850; -pub const SQLITE_IOERR_CLOSE: i32 = 4106; -pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; -pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; -pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; -pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; -pub const SQLITE_IOERR_SHMMAP: i32 = 5386; -pub const SQLITE_IOERR_SEEK: i32 = 5642; -pub const SQLITE_IOERR_DELETE_NOENT: i32 = 5898; -pub const SQLITE_IOERR_MMAP: i32 = 6154; -pub const SQLITE_IOERR_GETTEMPPATH: i32 = 6410; -pub const SQLITE_IOERR_CONVPATH: i32 = 6666; -pub const SQLITE_IOERR_VNODE: i32 = 6922; -pub const SQLITE_IOERR_AUTH: i32 = 7178; -pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; -pub const SQLITE_BUSY_RECOVERY: i32 = 261; -pub const SQLITE_BUSY_SNAPSHOT: i32 = 517; -pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; -pub const SQLITE_CANTOPEN_ISDIR: i32 = 526; -pub const SQLITE_CANTOPEN_FULLPATH: i32 = 782; -pub const SQLITE_CANTOPEN_CONVPATH: i32 = 1038; -pub const SQLITE_CORRUPT_VTAB: i32 = 267; -pub const SQLITE_READONLY_RECOVERY: i32 = 264; -pub const SQLITE_READONLY_CANTLOCK: i32 = 520; -pub const SQLITE_READONLY_ROLLBACK: i32 = 776; -pub const SQLITE_READONLY_DBMOVED: i32 = 1032; -pub const SQLITE_ABORT_ROLLBACK: i32 = 516; -pub const SQLITE_CONSTRAINT_CHECK: i32 = 275; -pub const SQLITE_CONSTRAINT_COMMITHOOK: i32 = 531; -pub const SQLITE_CONSTRAINT_FOREIGNKEY: i32 = 787; -pub const SQLITE_CONSTRAINT_FUNCTION: i32 = 1043; -pub const SQLITE_CONSTRAINT_NOTNULL: i32 = 1299; -pub const SQLITE_CONSTRAINT_PRIMARYKEY: i32 = 1555; -pub const SQLITE_CONSTRAINT_TRIGGER: i32 = 1811; -pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067; -pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323; -pub const SQLITE_CONSTRAINT_ROWID: i32 = 2579; -pub const SQLITE_NOTICE_RECOVER_WAL: i32 = 283; -pub const SQLITE_NOTICE_RECOVER_ROLLBACK: i32 = 539; -pub const SQLITE_WARNING_AUTOINDEX: i32 = 284; -pub const SQLITE_AUTH_USER: i32 = 279; -pub const SQLITE_OPEN_READONLY: i32 = 1; -pub const SQLITE_OPEN_READWRITE: i32 = 2; -pub const SQLITE_OPEN_CREATE: i32 = 4; -pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; -pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; -pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; -pub const SQLITE_OPEN_URI: i32 = 64; -pub const SQLITE_OPEN_MEMORY: i32 = 128; -pub const SQLITE_OPEN_MAIN_DB: i32 = 256; -pub const SQLITE_OPEN_TEMP_DB: i32 = 512; -pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; -pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; -pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; -pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; -pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; -pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; -pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; -pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; -pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; -pub const SQLITE_OPEN_WAL: i32 = 524288; -pub const SQLITE_IOCAP_ATOMIC: i32 = 1; -pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; -pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; -pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; -pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; -pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; -pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; -pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; -pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; -pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; -pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; -pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; -pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE: i32 = 4096; -pub const SQLITE_IOCAP_IMMUTABLE: i32 = 8192; -pub const SQLITE_LOCK_NONE: i32 = 0; -pub const SQLITE_LOCK_SHARED: i32 = 1; -pub const SQLITE_LOCK_RESERVED: i32 = 2; -pub const SQLITE_LOCK_PENDING: i32 = 3; -pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; -pub const SQLITE_SYNC_NORMAL: i32 = 2; -pub const SQLITE_SYNC_FULL: i32 = 3; -pub const SQLITE_SYNC_DATAONLY: i32 = 16; -pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; -pub const SQLITE_FCNTL_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_FCNTL_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_FCNTL_LAST_ERRNO: i32 = 4; -pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; -pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; -pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; -pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; -pub const SQLITE_FCNTL_WIN32_AV_RETRY: i32 = 9; -pub const SQLITE_FCNTL_PERSIST_WAL: i32 = 10; -pub const SQLITE_FCNTL_OVERWRITE: i32 = 11; -pub const SQLITE_FCNTL_VFSNAME: i32 = 12; -pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE: i32 = 13; -pub const SQLITE_FCNTL_PRAGMA: i32 = 14; -pub const SQLITE_FCNTL_BUSYHANDLER: i32 = 15; -pub const SQLITE_FCNTL_TEMPFILENAME: i32 = 16; -pub const SQLITE_FCNTL_MMAP_SIZE: i32 = 18; -pub const SQLITE_FCNTL_TRACE: i32 = 19; -pub const SQLITE_FCNTL_HAS_MOVED: i32 = 20; -pub const SQLITE_FCNTL_SYNC: i32 = 21; -pub const SQLITE_FCNTL_COMMIT_PHASETWO: i32 = 22; -pub const SQLITE_FCNTL_WIN32_SET_HANDLE: i32 = 23; -pub const SQLITE_FCNTL_WAL_BLOCK: i32 = 24; -pub const SQLITE_FCNTL_ZIPVFS: i32 = 25; -pub const SQLITE_FCNTL_RBU: i32 = 26; -pub const SQLITE_FCNTL_VFS_POINTER: i32 = 27; -pub const SQLITE_FCNTL_JOURNAL_POINTER: i32 = 28; -pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_LAST_ERRNO: i32 = 4; -pub const SQLITE_ACCESS_EXISTS: i32 = 0; -pub const SQLITE_ACCESS_READWRITE: i32 = 1; -pub const SQLITE_ACCESS_READ: i32 = 2; -pub const SQLITE_SHM_UNLOCK: i32 = 1; -pub const SQLITE_SHM_LOCK: i32 = 2; -pub const SQLITE_SHM_SHARED: i32 = 4; -pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; -pub const SQLITE_SHM_NLOCK: i32 = 8; -pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; -pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; -pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; -pub const SQLITE_CONFIG_MALLOC: i32 = 4; -pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; -pub const SQLITE_CONFIG_SCRATCH: i32 = 6; -pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; -pub const SQLITE_CONFIG_HEAP: i32 = 8; -pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; -pub const SQLITE_CONFIG_MUTEX: i32 = 10; -pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; -pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; -pub const SQLITE_CONFIG_PCACHE: i32 = 14; -pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; -pub const SQLITE_CONFIG_LOG: i32 = 16; -pub const SQLITE_CONFIG_URI: i32 = 17; -pub const SQLITE_CONFIG_PCACHE2: i32 = 18; -pub const SQLITE_CONFIG_GETPCACHE2: i32 = 19; -pub const SQLITE_CONFIG_COVERING_INDEX_SCAN: i32 = 20; -pub const SQLITE_CONFIG_SQLLOG: i32 = 21; -pub const SQLITE_CONFIG_MMAP_SIZE: i32 = 22; -pub const SQLITE_CONFIG_WIN32_HEAPSIZE: i32 = 23; -pub const SQLITE_CONFIG_PCACHE_HDRSZ: i32 = 24; -pub const SQLITE_CONFIG_PMASZ: i32 = 25; -pub const SQLITE_CONFIG_STMTJRNL_SPILL: i32 = 26; -pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; -pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; -pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; -pub const SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: i32 = 1004; -pub const SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: i32 = 1005; -pub const SQLITE_DENY: i32 = 1; -pub const SQLITE_IGNORE: i32 = 2; -pub const SQLITE_CREATE_INDEX: i32 = 1; -pub const SQLITE_CREATE_TABLE: i32 = 2; -pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; -pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; -pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; -pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; -pub const SQLITE_CREATE_TRIGGER: i32 = 7; -pub const SQLITE_CREATE_VIEW: i32 = 8; -pub const SQLITE_DELETE: i32 = 9; -pub const SQLITE_DROP_INDEX: i32 = 10; -pub const SQLITE_DROP_TABLE: i32 = 11; -pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; -pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; -pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; -pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; -pub const SQLITE_DROP_TRIGGER: i32 = 16; -pub const SQLITE_DROP_VIEW: i32 = 17; -pub const SQLITE_INSERT: i32 = 18; -pub const SQLITE_PRAGMA: i32 = 19; -pub const SQLITE_READ: i32 = 20; -pub const SQLITE_SELECT: i32 = 21; -pub const SQLITE_TRANSACTION: i32 = 22; -pub const SQLITE_UPDATE: i32 = 23; -pub const SQLITE_ATTACH: i32 = 24; -pub const SQLITE_DETACH: i32 = 25; -pub const SQLITE_ALTER_TABLE: i32 = 26; -pub const SQLITE_REINDEX: i32 = 27; -pub const SQLITE_ANALYZE: i32 = 28; -pub const SQLITE_CREATE_VTABLE: i32 = 29; -pub const SQLITE_DROP_VTABLE: i32 = 30; -pub const SQLITE_FUNCTION: i32 = 31; -pub const SQLITE_SAVEPOINT: i32 = 32; -pub const SQLITE_COPY: i32 = 0; -pub const SQLITE_RECURSIVE: i32 = 33; -pub const SQLITE_LIMIT_LENGTH: i32 = 0; -pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; -pub const SQLITE_LIMIT_COLUMN: i32 = 2; -pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; -pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; -pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; -pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; -pub const SQLITE_LIMIT_ATTACHED: i32 = 7; -pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; -pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; -pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; -pub const SQLITE_LIMIT_WORKER_THREADS: i32 = 11; -pub const SQLITE_INTEGER: i32 = 1; -pub const SQLITE_FLOAT: i32 = 2; -pub const SQLITE_BLOB: i32 = 4; -pub const SQLITE_NULL: i32 = 5; -pub const SQLITE_TEXT: i32 = 3; -pub const SQLITE3_TEXT: i32 = 3; -pub const SQLITE_UTF8: i32 = 1; -pub const SQLITE_UTF16LE: i32 = 2; -pub const SQLITE_UTF16BE: i32 = 3; -pub const SQLITE_UTF16: i32 = 4; -pub const SQLITE_ANY: i32 = 5; -pub const SQLITE_UTF16_ALIGNED: i32 = 8; -pub const SQLITE_DETERMINISTIC: i32 = 2048; -pub const SQLITE_INDEX_SCAN_UNIQUE: i32 = 1; -pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; -pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; -pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; -pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; -pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; -pub const SQLITE_INDEX_CONSTRAINT_LIKE: i32 = 65; -pub const SQLITE_INDEX_CONSTRAINT_GLOB: i32 = 66; -pub const SQLITE_INDEX_CONSTRAINT_REGEXP: i32 = 67; -pub const SQLITE_MUTEX_FAST: i32 = 0; -pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; -pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; -pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; -pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; -pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; -pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; -pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; -pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; -pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; -pub const SQLITE_MUTEX_STATIC_APP1: i32 = 8; -pub const SQLITE_MUTEX_STATIC_APP2: i32 = 9; -pub const SQLITE_MUTEX_STATIC_APP3: i32 = 10; -pub const SQLITE_MUTEX_STATIC_VFS1: i32 = 11; -pub const SQLITE_MUTEX_STATIC_VFS2: i32 = 12; -pub const SQLITE_MUTEX_STATIC_VFS3: i32 = 13; -pub const SQLITE_TESTCTRL_FIRST: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; -pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; -pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; -pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; -pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; -pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; -pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; -pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; -pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; -pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; -pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; -pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 17; -pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 18; -pub const SQLITE_TESTCTRL_EXPLAIN_STMT: i32 = 19; -pub const SQLITE_TESTCTRL_NEVER_CORRUPT: i32 = 20; -pub const SQLITE_TESTCTRL_VDBE_COVERAGE: i32 = 21; -pub const SQLITE_TESTCTRL_BYTEORDER: i32 = 22; -pub const SQLITE_TESTCTRL_ISINIT: i32 = 23; -pub const SQLITE_TESTCTRL_SORTER_MMAP: i32 = 24; -pub const SQLITE_TESTCTRL_IMPOSTER: i32 = 25; -pub const SQLITE_TESTCTRL_LAST: i32 = 25; -pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; -pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; -pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; -pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; -pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; -pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; -pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; -pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; -pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; -pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; -pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; -pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; -pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; -pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; -pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; -pub const SQLITE_DBSTATUS_CACHE_HIT: i32 = 7; -pub const SQLITE_DBSTATUS_CACHE_MISS: i32 = 8; -pub const SQLITE_DBSTATUS_CACHE_WRITE: i32 = 9; -pub const SQLITE_DBSTATUS_DEFERRED_FKS: i32 = 10; -pub const SQLITE_DBSTATUS_MAX: i32 = 10; -pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; -pub const SQLITE_STMTSTATUS_SORT: i32 = 2; -pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; -pub const SQLITE_STMTSTATUS_VM_STEP: i32 = 4; -pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; -pub const SQLITE_CHECKPOINT_FULL: i32 = 1; -pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; -pub const SQLITE_CHECKPOINT_TRUNCATE: i32 = 3; -pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; -pub const SQLITE_ROLLBACK: i32 = 1; -pub const SQLITE_FAIL: i32 = 3; -pub const SQLITE_REPLACE: i32 = 5; -pub const SQLITE_SCANSTAT_NLOOP: i32 = 0; -pub const SQLITE_SCANSTAT_NVISIT: i32 = 1; -pub const SQLITE_SCANSTAT_EST: i32 = 2; -pub const SQLITE_SCANSTAT_NAME: i32 = 3; -pub const SQLITE_SCANSTAT_EXPLAIN: i32 = 4; -pub const SQLITE_SCANSTAT_SELECTID: i32 = 5; -pub const NOT_WITHIN: i32 = 0; -pub const PARTLY_WITHIN: i32 = 1; -pub const FULLY_WITHIN: i32 = 2; -pub const FTS5_TOKENIZE_QUERY: i32 = 1; -pub const FTS5_TOKENIZE_PREFIX: i32 = 2; -pub const FTS5_TOKENIZE_DOCUMENT: i32 = 4; -pub const FTS5_TOKENIZE_AUX: i32 = 8; -pub const FTS5_TOKEN_COLOCATED: i32 = 1; -pub type va_list = __builtin_va_list; -pub type __gnuc_va_list = __builtin_va_list; -extern "C" { - #[link_name = "\u{1}sqlite3_version"] - pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3 { - _unused: [u8; 0], -} -pub type sqlite_int64 = ::std::os::raw::c_longlong; -pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; -pub type sqlite3_int64 = sqlite_int64; -pub type sqlite3_uint64 = sqlite_uint64; -pub type sqlite3_callback = ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_file { - pub pMethods: *const sqlite3_io_methods, -} -#[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_file)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_file)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_file), - "::", - stringify!(pMethods) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_io_methods { - pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xRead: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *mut ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xWrite: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *const ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pSize: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xUnlock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCheckReservedLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileControl: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - op: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xSectorSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xDeviceCharacteristics: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xShmMap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iPg: ::std::os::raw::c_int, - pgsz: ::std::os::raw::c_int, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xShmLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - offset: ::std::os::raw::c_int, - n: ::std::os::raw::c_int, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xShmBarrier: ::std::option::Option, - pub xShmUnmap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - deleteFlag: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iOfst: sqlite3_int64, - iAmt: ::std::os::raw::c_int, - pp: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xUnfetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iOfst: sqlite3_int64, - p: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_io_methods() { - assert_eq!( - ::std::mem::size_of::(), - 152usize, - concat!("Size of: ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xRead) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xWrite) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnlock) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xCheckReservedLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileControl) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSectorSize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ - as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xDeviceCharacteristics) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmMap) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmBarrier) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmUnmap) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnfetch as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnfetch) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex { - _unused: [u8; 0], -} -pub type sqlite3_syscall_ptr = ::std::option::Option; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vfs { - pub iVersion: ::std::os::raw::c_int, - pub szOsFile: ::std::os::raw::c_int, - pub mxPathname: ::std::os::raw::c_int, - pub pNext: *mut sqlite3_vfs, - pub zName: *const ::std::os::raw::c_char, - pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - pOutFlags: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - syncDir: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xAccess: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - flags: ::std::os::raw::c_int, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFullPathname: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - nOut: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xDlOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zFilename: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void, - >, - pub xDlError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zErrMsg: *mut ::std::os::raw::c_char, - ), - >, - pub xDlSym: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ) -> ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ), - >, - >, - pub xDlClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), - >, - pub xRandomness: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSleep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - microseconds: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTime: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, - >, - pub xGetLastError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTimeInt64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xSetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: sqlite3_syscall_ptr, - ) -> ::std::os::raw::c_int, - >, - pub xGetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> sqlite3_syscall_ptr, - >, - pub xNextSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!( - ::std::mem::size_of::(), - 168usize, - concat!("Size of: ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(szOsFile) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(mxPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(zName) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pAppData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xAccess) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xFullPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlSym) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xRandomness) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSleep) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTime) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetLastError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTimeInt64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xNextSystemCall) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xRoundup: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub pAppData: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!( - ::std::mem::size_of::(), - 64usize, - concat!("Size of: ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xMalloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xFree) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRealloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRoundup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(pAppData) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Mem { - _unused: [u8; 0], -} -pub type sqlite3_value = Mem; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_context { - _unused: [u8; 0], -} -pub type sqlite3_destructor_type = - ::std::option::Option; -extern "C" { - #[link_name = "\u{1}sqlite3_temp_directory"] - pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; -} -extern "C" { - #[link_name = "\u{1}sqlite3_data_directory"] - pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xConnect: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xBestIndex: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: *mut sqlite3_index_info, - ) -> ::std::os::raw::c_int, - >, - pub xDisconnect: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xDestroy: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - ppCursor: *mut *mut sqlite3_vtab_cursor, - ) -> ::std::os::raw::c_int, - >, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xFilter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - idxNum: ::std::os::raw::c_int, - idxStr: *const ::std::os::raw::c_char, - argc: ::std::os::raw::c_int, - argv: *mut *mut sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub xNext: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xEof: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - arg2: *mut sqlite3_context, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - pRowid: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xUpdate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - arg4: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xBegin: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xCommit: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xRollback: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xFindFunction: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - nArg: ::std::os::raw::c_int, - zName: *const ::std::os::raw::c_char, - pxFunc: *mut ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - ppArg: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xRename: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - zNew: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSavepoint: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRelease: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRollbackTo: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!( - ::std::mem::size_of::(), - 184usize, - concat!("Size of: ", stringify!(sqlite3_module)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_module)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xConnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBestIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDisconnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFilter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xEof) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xColumn) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xUpdate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBegin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCommit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollback) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFindFunction) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRename) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSavepoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRelease) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollbackTo) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info { - pub nConstraint: ::std::os::raw::c_int, - pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, - pub nOrderBy: ::std::os::raw::c_int, - pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, - pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, - pub idxNum: ::std::os::raw::c_int, - pub idxStr: *mut ::std::os::raw::c_char, - pub needToFreeIdxStr: ::std::os::raw::c_int, - pub orderByConsumed: ::std::os::raw::c_int, - pub estimatedCost: f64, - pub estimatedRows: sqlite3_int64, - pub idxFlags: ::std::os::raw::c_int, - pub colUsed: sqlite3_uint64, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint { - pub iColumn: ::std::os::raw::c_int, - pub op: ::std::os::raw::c_uchar, - pub usable: ::std::os::raw::c_uchar, - pub iTermOffset: ::std::os::raw::c_int, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).op as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(op) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).usable - as *const _ as usize - }, - 5usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(usable) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iTermOffset - as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iTermOffset) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_orderby { - pub iColumn: ::std::os::raw::c_int, - pub desc: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).desc as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(desc) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint_usage { - pub argvIndex: ::std::os::raw::c_int, - pub omit: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).argvIndex - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(argvIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).omit - as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(omit) - ) - ); -} -#[test] -fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!( - ::std::mem::size_of::(), - 96usize, - concat!("Size of: ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nOrderBy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aOrderBy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraintUsage) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxNum) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(needToFreeIdxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(orderByConsumed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedCost as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedCost) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedRows as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedRows) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxFlags as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxFlags) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).colUsed as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(colUsed) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(pModule) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(nRef) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(zErrMsg) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab_cursor { - pub pVtab: *mut sqlite3_vtab, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab_cursor), - "::", - stringify!(pVtab) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexNotheld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexInit as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnd) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexAlloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexFree as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexFree) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexTry) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexLeave) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexHeld) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexNotheld) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_page { - pub pBuf: *mut ::std::os::raw::c_void, - pub pExtra: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_page() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(sqlite3_pcache_page)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_page)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_page), - "::", - stringify!(pBuf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_page), - "::", - stringify!(pExtra) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods2 { - pub iVersion: ::std::os::raw::c_int, - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - szExtra: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache_page, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut sqlite3_pcache_page, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut sqlite3_pcache_page, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, - pub xShrink: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods2() { - assert_eq!( - ::std::mem::size_of::(), - 104usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iVersion as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDestroy as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xShrink) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods { - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!( - ::std::mem::size_of::(), - 88usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xDestroy) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_backup { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_snapshot { - _unused: [u8; 0], -} -pub type sqlite3_rtree_dbl = f64; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_rtree_geometry { - pub pContext: *mut ::std::os::raw::c_void, - pub nParam: ::std::os::raw::c_int, - pub aParam: *mut sqlite3_rtree_dbl, - pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_rtree_geometry() { - assert_eq!( - ::std::mem::size_of::(), - 40usize, - concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pContext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(nParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(aParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pUser) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(xDelUser) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_rtree_query_info { - pub pContext: *mut ::std::os::raw::c_void, - pub nParam: ::std::os::raw::c_int, - pub aParam: *mut sqlite3_rtree_dbl, - pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, - pub aCoord: *mut sqlite3_rtree_dbl, - pub anQueue: *mut ::std::os::raw::c_uint, - pub nCoord: ::std::os::raw::c_int, - pub iLevel: ::std::os::raw::c_int, - pub mxLevel: ::std::os::raw::c_int, - pub iRowid: sqlite3_int64, - pub rParentScore: sqlite3_rtree_dbl, - pub eParentWithin: ::std::os::raw::c_int, - pub eWithin: ::std::os::raw::c_int, - pub rScore: sqlite3_rtree_dbl, - pub apSqlParam: *mut *mut sqlite3_value, -} -#[test] -fn bindgen_test_layout_sqlite3_rtree_query_info() { - assert_eq!( - ::std::mem::size_of::(), - 112usize, - concat!("Size of: ", stringify!(sqlite3_rtree_query_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_rtree_query_info)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).pContext as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(pContext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(nParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(aParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(pUser) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDelUser as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(xDelUser) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aCoord as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(aCoord) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).anQueue as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(anQueue) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nCoord as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(nCoord) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iLevel as *const _ as usize }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(iLevel) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mxLevel as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(mxLevel) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iRowid as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(iRowid) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rParentScore as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(rParentScore) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).eParentWithin as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(eParentWithin) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).eWithin as *const _ as usize - }, - 92usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(eWithin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).rScore as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(rScore) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).apSqlParam as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(apSqlParam) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5Context { - _unused: [u8; 0], -} -pub type fts5_extension_function = ::std::option::Option< - unsafe extern "C" fn( - pApi: *const Fts5ExtensionApi, - pFts: *mut Fts5Context, - pCtx: *mut sqlite3_context, - nVal: ::std::os::raw::c_int, - apVal: *mut *mut sqlite3_value, - ), ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5PhraseIter { - pub a: *const ::std::os::raw::c_uchar, - pub b: *const ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_Fts5PhraseIter() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(Fts5PhraseIter)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Fts5PhraseIter)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).a as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Fts5PhraseIter), - "::", - stringify!(a) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).b as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Fts5PhraseIter), - "::", - stringify!(b) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5ExtensionApi { - pub iVersion: ::std::os::raw::c_int, - pub xUserData: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> *mut ::std::os::raw::c_void, - >, - pub xColumnCount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, - >, - pub xRowCount: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pnRow: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xColumnTotalSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pnToken: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTokenize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pText: *const ::std::os::raw::c_char, - nText: ::std::os::raw::c_int, - pCtx: *mut ::std::os::raw::c_void, - xToken: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, - arg6: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseCount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, - >, - pub xPhraseSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xInstCount: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pnInst: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xInst: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iIdx: ::std::os::raw::c_int, - piPhrase: *mut ::std::os::raw::c_int, - piCol: *mut ::std::os::raw::c_int, - piOff: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: - ::std::option::Option sqlite3_int64>, - pub xColumnText: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pz: *mut *const ::std::os::raw::c_char, - pn: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xColumnSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pnToken: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xQueryPhrase: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - pUserData: *mut ::std::os::raw::c_void, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const Fts5ExtensionApi, - arg2: *mut Fts5Context, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub xSetAuxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pAux: *mut ::std::os::raw::c_void, - xDelete: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub xGetAuxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - bClear: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xPhraseFirst: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - arg2: *mut Fts5PhraseIter, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseNext: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - arg2: *mut Fts5PhraseIter, - piCol: *mut ::std::os::raw::c_int, - piOff: *mut ::std::os::raw::c_int, - ), - >, - pub xPhraseFirstColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - arg2: *mut Fts5PhraseIter, - arg3: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseNextColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - arg2: *mut Fts5PhraseIter, - piCol: *mut ::std::os::raw::c_int, - ), - >, -} -#[test] -fn bindgen_test_layout_Fts5ExtensionApi() { - assert_eq!( - ::std::mem::size_of::(), - 160usize, - concat!("Size of: ", stringify!(Fts5ExtensionApi)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Fts5ExtensionApi)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUserData as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xUserData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnCount as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowCount as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xRowCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xColumnTotalSize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnTotalSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xTokenize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseCount as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseSize as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInstCount as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xInstCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInst as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xInst) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnText as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnText) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnSize as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xQueryPhrase as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xQueryPhrase) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSetAuxdata as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xSetAuxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetAuxdata as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xGetAuxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseFirst as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseFirst) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseNext as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseNext) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPhraseFirstColumn as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseFirstColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPhraseNextColumn as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseNextColumn) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5Tokenizer { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct fts5_tokenizer { - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - azArg: *mut *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ppOut: *mut *mut Fts5Tokenizer, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option, - pub xTokenize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Tokenizer, - pCtx: *mut ::std::os::raw::c_void, - flags: ::std::os::raw::c_int, - pText: *const ::std::os::raw::c_char, - nText: ::std::os::raw::c_int, - xToken: ::std::option::Option< - unsafe extern "C" fn( - pCtx: *mut ::std::os::raw::c_void, - tflags: ::std::os::raw::c_int, - pToken: *const ::std::os::raw::c_char, - nToken: ::std::os::raw::c_int, - iStart: ::std::os::raw::c_int, - iEnd: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_fts5_tokenizer() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(fts5_tokenizer)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(fts5_tokenizer)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xTokenize) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct fts5_api { - pub iVersion: ::std::os::raw::c_int, - pub xCreateTokenizer: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - pContext: *mut ::std::os::raw::c_void, - pTokenizer: *mut fts5_tokenizer, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub xFindTokenizer: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - ppContext: *mut *mut ::std::os::raw::c_void, - pTokenizer: *mut fts5_tokenizer, - ) -> ::std::os::raw::c_int, - >, - pub xCreateFunction: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - pContext: *mut ::std::os::raw::c_void, - xFunction: fts5_extension_function, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_fts5_api() { - assert_eq!( - ::std::mem::size_of::(), - 32usize, - concat!("Size of: ", stringify!(fts5_api)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(fts5_api)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreateTokenizer as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xCreateTokenizer) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindTokenizer as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xFindTokenizer) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreateFunction as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xCreateFunction) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_api_routines { - pub aggregate_context: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub aggregate_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, - >, - pub bind_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_double: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, - ) -> ::std::os::raw::c_int, - >, - pub bind_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_int64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, - ) -> ::std::os::raw::c_int, - >, - pub bind_null: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub bind_parameter_index: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub bind_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub busy_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub busy_timeout: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub changes: - ::std::option::Option ::std::os::raw::c_int>, - pub close: - ::std::option::Option ::std::os::raw::c_int>, - pub collation_needed: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub collation_needed16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub column_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_bytes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_bytes16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub column_database_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_database_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_decltype: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_decltype16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_double: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, - >, - pub column_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_int64: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, - >, - pub column_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_origin_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_origin_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_table_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_table_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_uchar, - >, - pub column_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_type: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *mut sqlite3_value, - >, - pub commit_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub complete: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, - pub complete16: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub create_collation: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_collation16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_function16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_module: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub data_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub db_handle: - ::std::option::Option *mut sqlite3>, - pub declare_vtab: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub enable_shared_cache: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub errcode: - ::std::option::Option ::std::os::raw::c_int>, - pub errmsg: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, - >, - pub errmsg16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, - >, - pub exec: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub expired: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub finalize: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub free: ::std::option::Option, - pub free_table: - ::std::option::Option, - pub get_autocommit: - ::std::option::Option ::std::os::raw::c_int>, - pub get_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub get_table: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub global_recover: ::std::option::Option ::std::os::raw::c_int>, - pub interruptx: ::std::option::Option, - pub last_insert_rowid: - ::std::option::Option sqlite_int64>, - pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, - pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, - pub malloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub mprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub open16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub prepare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub profile: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub progress_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, - ), - >, - pub realloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub reset: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub result_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_double: - ::std::option::Option, - pub result_error: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_error16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_int64: - ::std::option::Option, - pub result_null: ::std::option::Option, - pub result_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16be: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16le: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_value: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), - >, - pub rollback_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub set_authorizer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub set_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, - ), - >, - pub snprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub step: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub table_column_metadata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub thread_cleanup: ::std::option::Option, - pub total_changes: - ::std::option::Option ::std::os::raw::c_int>, - pub trace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub transfer_bindings: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, - ) -> ::std::os::raw::c_int, - >, - pub update_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub user_data: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, - >, - pub value_blob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_bytes16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_double: ::std::option::Option f64>, - pub value_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_int64: - ::std::option::Option sqlite_int64>, - pub value_numeric_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_text: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, - >, - pub value_text16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16be: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16le: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub vmprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char, - >, - pub overload_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub prepare_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub clear_bindings: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub create_module_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_zeroblob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_close: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, - ) -> ::std::os::raw::c_int, - >, - pub blob_read: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_write: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub create_collation_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub file_control: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub memory_highwater: - ::std::option::Option sqlite3_int64>, - pub memory_used: ::std::option::Option sqlite3_int64>, - pub mutex_alloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub mutex_enter: ::std::option::Option, - pub mutex_free: ::std::option::Option, - pub mutex_leave: ::std::option::Option, - pub mutex_try: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub open_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub release_memory: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub result_error_nomem: ::std::option::Option, - pub result_error_toobig: - ::std::option::Option, - pub sleep: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub soft_heap_limit: ::std::option::Option, - pub vfs_find: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, - >, - pub vfs_register: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub vfs_unregister: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, - >, - pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, - pub result_zeroblob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_error_code: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub test_control: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, - >, - pub randomness: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), - >, - pub context_db_handle: - ::std::option::Option *mut sqlite3>, - pub extended_result_codes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub limit: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub next_stmt: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, - >, - pub sql: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, - >, - pub status: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub backup_finish: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_init: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut sqlite3, - arg4: *const ::std::os::raw::c_char, - ) -> *mut sqlite3_backup, - >, - pub backup_pagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_remaining: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_step: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_backup, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub compileoption_get: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, - >, - pub compileoption_used: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, - pub create_function_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub db_config: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int, - >, - pub db_mutex: - ::std::option::Option *mut sqlite3_mutex>, - pub db_status: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub extended_errcode: - ::std::option::Option ::std::os::raw::c_int>, - pub log: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char, ...), - >, - pub soft_heap_limit64: - ::std::option::Option sqlite3_int64>, - pub sourceid: ::std::option::Option *const ::std::os::raw::c_char>, - pub stmt_status: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub strnicmp: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub unlock_notify: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub wal_autocheckpoint: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub wal_checkpoint: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub wal_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub blob_reopen: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob, arg2: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub vtab_config: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int, - >, - pub vtab_on_conflict: - ::std::option::Option ::std::os::raw::c_int>, - pub close_v2: - ::std::option::Option ::std::os::raw::c_int>, - pub db_filename: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, - pub db_readonly: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub db_release_memory: - ::std::option::Option ::std::os::raw::c_int>, - pub errstr: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, - >, - pub stmt_busy: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub stmt_readonly: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub stricmp: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub uri_boolean: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub uri_int64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_int64, - ) -> sqlite3_int64, - >, - pub uri_parameter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, - pub vsnprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char, - >, - pub wal_checkpoint_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub auto_extension: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_blob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_text64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - arg6: ::std::os::raw::c_uchar, - ) -> ::std::os::raw::c_int, - >, - pub cancel_auto_extension: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub load_extension: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub malloc64: ::std::option::Option< - unsafe extern "C" fn(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void, - >, - pub msize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64, - >, - pub realloc64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: sqlite3_uint64, - ) -> *mut ::std::os::raw::c_void, - >, - pub reset_auto_extension: ::std::option::Option, - pub result_blob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - ), - >, - pub result_text64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - arg5: ::std::os::raw::c_uchar, - ), - >, - pub strglob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub value_dup: ::std::option::Option< - unsafe extern "C" fn(arg1: *const sqlite3_value) -> *mut sqlite3_value, - >, - pub value_free: ::std::option::Option, - pub result_zeroblob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: sqlite3_uint64, - ) -> ::std::os::raw::c_int, - >, - pub bind_zeroblob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_uint64, - ) -> ::std::os::raw::c_int, - >, - pub value_subtype: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint, - >, - pub result_subtype: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint), - >, - pub status64: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut sqlite3_int64, - arg3: *mut sqlite3_int64, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub strlike: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_uint, - ) -> ::std::os::raw::c_int, - >, - pub db_cacheflush: - ::std::option::Option ::std::os::raw::c_int>, - pub system_errno: - ::std::option::Option ::std::os::raw::c_int>, -} -#[test] -fn bindgen_test_layout_sqlite3_api_routines() { - assert_eq!( - ::std::mem::size_of::(), - 1712usize, - concat!("Size of: ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_context as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_context) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_count as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_double as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_count as *const _ - as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_index as *const _ - as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_index) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_name as *const _ - as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_text16 as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_handler as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_handler) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_timeout as *const _ as usize - }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_timeout) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(close) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed as *const _ as usize - }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_blob as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes as *const _ as usize - }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize - }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_count as *const _ as usize - }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name as *const _ - as usize - }, - 184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name16 as *const _ - as usize - }, - 192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype as *const _ as usize - }, - 200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize - }, - 208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_double as *const _ as usize - }, - 216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, - 224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_int64 as *const _ as usize - }, - 232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name as *const _ as usize - }, - 240usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name16 as *const _ as usize - }, - 248usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name as *const _ as usize - }, - 256usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name16 as *const _ - as usize - }, - 264usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name as *const _ as usize - }, - 272usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name16 as *const _ - as usize - }, - 280usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text as *const _ as usize - }, - 288usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text16 as *const _ as usize - }, - 296usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_type as *const _ as usize - }, - 304usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_type) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_value as *const _ as usize - }, - 312usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).commit_hook as *const _ as usize - }, - 320usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(commit_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, - 328usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, - 336usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation as *const _ as usize - }, - 344usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation16 as *const _ as usize - }, - 352usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function as *const _ as usize - }, - 360usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function16 as *const _ as usize - }, - 368usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module as *const _ as usize - }, - 376usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, - 384usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(data_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, - 392usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).declare_vtab as *const _ as usize - }, - 400usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(declare_vtab) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).enable_shared_cache as *const _ - as usize - }, - 408usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(enable_shared_cache) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, - 416usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, - 424usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, - 432usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, - 440usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(exec) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, - 448usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(expired) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, - 456usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(finalize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, - 464usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, - 472usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_autocommit as *const _ as usize - }, - 480usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_autocommit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_auxdata as *const _ as usize - }, - 488usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, - 496usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).global_recover as *const _ as usize - }, - 504usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(global_recover) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, - 512usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(interruptx) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize - }, - 520usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(last_insert_rowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, - 528usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).libversion_number as *const _ as usize - }, - 536usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion_number) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, - 544usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(malloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, - 552usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, - 560usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, - 568usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, - 576usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, - 584usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, - 592usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(profile) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).progress_handler as *const _ as usize - }, - 600usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(progress_handler) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, - 608usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(realloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, - 616usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(reset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_blob as *const _ as usize - }, - 624usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_double as *const _ as usize - }, - 632usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_double) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error as *const _ as usize - }, - 640usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error16 as *const _ as usize - }, - 648usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, - 656usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_int64 as *const _ as usize - }, - 664usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_null as *const _ as usize - }, - 672usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text as *const _ as usize - }, - 680usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16 as *const _ as usize - }, - 688usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16be as *const _ as usize - }, - 696usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16le as *const _ as usize - }, - 704usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16le) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_value as *const _ as usize - }, - 712usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rollback_hook as *const _ as usize - }, - 720usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(rollback_hook) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_authorizer as *const _ as usize - }, - 728usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_authorizer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_auxdata as *const _ as usize - }, - 736usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).snprintf as *const _ as usize }, - 744usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(snprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, - 752usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(step) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).table_column_metadata as *const _ - as usize - }, - 760usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(table_column_metadata) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize - }, - 768usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(thread_cleanup) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).total_changes as *const _ as usize - }, - 776usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(total_changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, - 784usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(trace) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize - }, - 792usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(transfer_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).update_hook as *const _ as usize - }, - 800usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(update_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, - 808usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(user_data) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, - 816usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes as *const _ as usize - }, - 824usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize - }, - 832usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_double as *const _ as usize - }, - 840usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, - 848usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_int64 as *const _ as usize - }, - 856usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize - }, - 864usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_numeric_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, - 872usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16 as *const _ as usize - }, - 880usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16be as *const _ as usize - }, - 888usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16le as *const _ as usize - }, - 896usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16le) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, - 904usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, - 912usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vmprintf) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).overload_function as *const _ as usize - }, - 920usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(overload_function) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, - 928usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize - }, - 936usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).clear_bindings as *const _ as usize - }, - 944usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(clear_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize - }, - 952usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize - }, - 960usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_zeroblob) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, - 968usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_bytes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, - 976usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_close) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, - 984usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, - 992usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_read) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, - 1000usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_write) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation_v2 as *const _ - as usize - }, - 1008usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).file_control as *const _ as usize - }, - 1016usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(file_control) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_highwater as *const _ as usize - }, - 1024usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_highwater) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_used as *const _ as usize - }, - 1032usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_used) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize - }, - 1040usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_alloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_enter as *const _ as usize - }, - 1048usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_enter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, - 1056usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_free) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_leave as *const _ as usize - }, - 1064usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_leave) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, - 1072usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_try) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, - 1080usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).release_memory as *const _ as usize - }, - 1088usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(release_memory) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize - }, - 1096usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_nomem) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_toobig as *const _ - as usize - }, - 1104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_toobig) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, - 1112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sleep) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize - }, - 1120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(soft_heap_limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, - 1128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_find) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_register as *const _ as usize - }, - 1136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_register) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize - }, - 1144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_unregister) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize - }, - 1152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(xthreadsafe) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize - }, - 1160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_zeroblob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_code as *const _ as usize - }, - 1168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_code) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).test_control as *const _ as usize - }, - 1176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(test_control) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, - 1184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(randomness) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).context_db_handle as *const _ as usize - }, - 1192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(context_db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).extended_result_codes as *const _ - as usize - }, - 1200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(extended_result_codes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, - 1208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, - 1216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(next_stmt) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, - 1224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sql) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, - 1232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(status) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_finish as *const _ as usize - }, - 1240usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_finish) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_init as *const _ as usize - }, - 1248usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_init) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_pagecount as *const _ as usize - }, - 1256usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_pagecount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_remaining as *const _ as usize - }, - 1264usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_remaining) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_step as *const _ as usize - }, - 1272usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_step) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).compileoption_get as *const _ as usize - }, - 1280usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(compileoption_get) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).compileoption_used as *const _ as usize - }, - 1288usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(compileoption_used) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function_v2 as *const _ as usize - }, - 1296usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function_v2) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_config as *const _ as usize }, - 1304usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_config) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_mutex as *const _ as usize }, - 1312usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_mutex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_status as *const _ as usize }, - 1320usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_status) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).extended_errcode as *const _ as usize - }, - 1328usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(extended_errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).log as *const _ as usize }, - 1336usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(log) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).soft_heap_limit64 as *const _ as usize - }, - 1344usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(soft_heap_limit64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sourceid as *const _ as usize }, - 1352usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sourceid) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stmt_status as *const _ as usize - }, - 1360usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_status) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).strnicmp as *const _ as usize }, - 1368usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(strnicmp) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).unlock_notify as *const _ as usize - }, - 1376usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(unlock_notify) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_autocheckpoint as *const _ as usize - }, - 1384usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_autocheckpoint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_checkpoint as *const _ as usize - }, - 1392usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_checkpoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).wal_hook as *const _ as usize }, - 1400usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_hook) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).blob_reopen as *const _ as usize - }, - 1408usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_reopen) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtab_config as *const _ as usize - }, - 1416usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vtab_config) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtab_on_conflict as *const _ as usize - }, - 1424usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vtab_on_conflict) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).close_v2 as *const _ as usize }, - 1432usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(close_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_filename as *const _ as usize - }, - 1440usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_filename) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_readonly as *const _ as usize - }, - 1448usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_readonly) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_release_memory as *const _ as usize - }, - 1456usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_release_memory) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errstr as *const _ as usize }, - 1464usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errstr) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).stmt_busy as *const _ as usize }, - 1472usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_busy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stmt_readonly as *const _ as usize - }, - 1480usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_readonly) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).stricmp as *const _ as usize }, - 1488usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stricmp) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).uri_boolean as *const _ as usize - }, - 1496usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(uri_boolean) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).uri_int64 as *const _ as usize }, - 1504usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(uri_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).uri_parameter as *const _ as usize - }, - 1512usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(uri_parameter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vsnprintf as *const _ as usize }, - 1520usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vsnprintf) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_checkpoint_v2 as *const _ as usize - }, - 1528usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_checkpoint_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).auto_extension as *const _ as usize - }, - 1536usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(auto_extension) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_blob64 as *const _ as usize - }, - 1544usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_blob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_text64 as *const _ as usize - }, - 1552usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).cancel_auto_extension as *const _ - as usize - }, - 1560usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(cancel_auto_extension) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).load_extension as *const _ as usize - }, - 1568usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(load_extension) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).malloc64 as *const _ as usize }, - 1576usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(malloc64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).msize as *const _ as usize }, - 1584usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(msize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).realloc64 as *const _ as usize }, - 1592usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(realloc64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).reset_auto_extension as *const _ - as usize - }, - 1600usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(reset_auto_extension) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_blob64 as *const _ as usize - }, - 1608usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_blob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text64 as *const _ as usize - }, - 1616usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).strglob as *const _ as usize }, - 1624usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(strglob) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_dup as *const _ as usize }, - 1632usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_dup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_free as *const _ as usize }, - 1640usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_free) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_zeroblob64 as *const _ as usize - }, - 1648usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_zeroblob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_zeroblob64 as *const _ as usize - }, - 1656usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_zeroblob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_subtype as *const _ as usize - }, - 1664usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_subtype) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_subtype as *const _ as usize - }, - 1672usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_subtype) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).status64 as *const _ as usize }, - 1680usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(status64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).strlike as *const _ as usize }, - 1688usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(strlike) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_cacheflush as *const _ as usize - }, - 1696usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_cacheflush) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).system_errno as *const _ as usize - }, - 1704usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(system_errno) - ) - ); -} -pub type __builtin_va_list = [__va_list_tag; 1usize]; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct __va_list_tag { - pub gp_offset: ::std::os::raw::c_uint, - pub fp_offset: ::std::os::raw::c_uint, - pub overflow_arg_area: *mut ::std::os::raw::c_void, - pub reg_save_area: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout___va_list_tag() { - assert_eq!( - ::std::mem::size_of::<__va_list_tag>(), - 24usize, - concat!("Size of: ", stringify!(__va_list_tag)) - ); - assert_eq!( - ::std::mem::align_of::<__va_list_tag>(), - 8usize, - concat!("Alignment of ", stringify!(__va_list_tag)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(gp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(fp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(overflow_arg_area) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(reg_save_area) - ) - ); -} - -// bindings were built with (non-embedded) loadable_extension: -// we define our own sqlite_api static variable and export it -// to C -#[no_mangle] -pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_routines; - -// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) - -pub unsafe fn sqlite3_aggregate_context( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_context.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_context", - " function" - )))(arg1, nBytes) -} - -pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_blob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_blob", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_double( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_double", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_null( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_null", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_parameter_index( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_index.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_index", - " function" - )))(arg1, zName) -} - -pub unsafe fn sqlite3_bind_parameter_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_text( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_text16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_bind_value( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_value", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_handler( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_handler", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_timeout( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_timeout.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_timeout", - " function" - )))(arg1, ms) -} - -pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_collation_needed( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_collation_needed16( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_column_blob( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_blob", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_column_database_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_database_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_decltype( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype", - " function" - )))(arg1, i) -} - -pub unsafe fn sqlite3_column_decltype16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_double", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int64( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int64", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_text( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_text16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_type( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_type", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_value( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_value", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_commit_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).commit_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "commit_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete16", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_create_collation( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_collation16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_function( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_function16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function16", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_module( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).data_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "data_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_declare_vtab( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).declare_vtab.expect(stringify!( - "sqlite3_api contains null pointer for ", - "declare_vtab", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).enable_shared_cache.expect(stringify!( - "sqlite3_api contains null pointer for ", - "enable_shared_cache", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errcode", - " function" - )))(db) -} - -pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_exec( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).exec.expect(stringify!( - "sqlite3_api contains null pointer for ", - "exec", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).expired.expect(stringify!( - "sqlite3_api contains null pointer for ", - "expired", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).finalize.expect(stringify!( - "sqlite3_api contains null pointer for ", - "finalize", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free_table", - " function" - )))(result) -} - -pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_autocommit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_autocommit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_get_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_auxdata", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_get_table( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_table", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).global_recover.expect(stringify!( - "sqlite3_api contains null pointer for ", - "global_recover", - " function" - )))() -} - -pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).interruptx.expect(stringify!( - "sqlite3_api contains null pointer for ", - "interruptx", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).last_insert_rowid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "last_insert_rowid", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion", - " function" - )))() -} - -pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion_number.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion_number", - " function" - )))() -} - -pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).malloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "malloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mprintf( - arg1: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mprintf", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_open( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_open16( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_prepare( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_profile( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).profile.expect(stringify!( - "sqlite3_api contains null pointer for ", - "profile", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_progress_handler( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).progress_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "progress_handler", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_realloc( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).realloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "realloc", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).reset.expect(stringify!( - "sqlite3_api contains null pointer for ", - "reset", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_result_blob( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_blob", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_double", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_error16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_null", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_text( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16be( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16be", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16le( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16le", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_value", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_rollback_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).rollback_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "rollback_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_authorizer( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_authorizer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_authorizer", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_auxdata", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_snprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).snprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "snprintf", - " function" - )))(arg1, arg2, arg3, vararg1) -} - -pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).step.expect(stringify!( - "sqlite3_api contains null pointer for ", - "step", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_table_column_metadata( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).table_column_metadata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "table_column_metadata", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) -} - -pub unsafe fn sqlite3_thread_cleanup() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).thread_cleanup.expect(stringify!( - "sqlite3_api contains null pointer for ", - "thread_cleanup", - " function" - )))() -} - -pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).total_changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "total_changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_trace( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).trace.expect(stringify!( - "sqlite3_api contains null pointer for ", - "trace", - " function" - )))(arg1, xTrace, arg2) -} - -pub unsafe fn sqlite3_transfer_bindings( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).transfer_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "transfer_bindings", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_update_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).update_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "update_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).user_data.expect(stringify!( - "sqlite3_api contains null pointer for ", - "user_data", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_blob", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_double", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_numeric_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_numeric_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16be", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16le", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vmprintf( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vmprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vmprintf", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_overload_function( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).overload_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "overload_function", - " function" - )))(arg1, zFuncName, nArg) -} - -pub unsafe fn sqlite3_prepare_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).clear_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "clear_bindings", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_module_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module_v2", - " function" - )))(arg1, arg2, arg3, arg4, xDestroy) -} - -pub unsafe fn sqlite3_bind_zeroblob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_zeroblob", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_open( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_open", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) -} - -pub unsafe fn sqlite3_blob_read( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_read.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_read", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_blob_write( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_write.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_write", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_create_collation_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_file_control( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).file_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "file_control", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_highwater.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_highwater", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_used.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_used", - " function" - )))() -} - -pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_alloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_alloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_enter.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_enter", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_leave.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_leave", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_try.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_try", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_open_v2( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open_v2", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).release_memory.expect(stringify!( - "sqlite3_api contains null pointer for ", - "release_memory", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_nomem.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_nomem", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_toobig.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_toobig", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sleep.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sleep", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).soft_heap_limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "soft_heap_limit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_find.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_find", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_register( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_register.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_register", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_unregister.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_unregister", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).xthreadsafe.expect(stringify!( - "sqlite3_api contains null pointer for ", - "xthreadsafe", - " function" - )))() -} - -pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_zeroblob", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_code.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_code", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_test_control( - arg1: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).test_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "test_control", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).randomness.expect(stringify!( - "sqlite3_api contains null pointer for ", - "randomness", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).context_db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "context_db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_extended_result_codes( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).extended_result_codes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "extended_result_codes", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_limit( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "limit", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).next_stmt.expect(stringify!( - "sqlite3_api contains null pointer for ", - "next_stmt", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sql.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sql", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_status( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "status", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_finish.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_finish", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_init( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut sqlite3, - arg4: *const ::std::os::raw::c_char, -) -> *mut sqlite3_backup { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_init.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_init", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_pagecount.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_pagecount", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_remaining.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_remaining", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_step( - arg1: *mut sqlite3_backup, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_step.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_step", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_compileoption_get( - arg1: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).compileoption_get.expect(stringify!( - "sqlite3_api contains null pointer for ", - "compileoption_get", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_compileoption_used( - arg1: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).compileoption_used.expect(stringify!( - "sqlite3_api contains null pointer for ", - "compileoption_used", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_function_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal, xDestroy) -} - -pub unsafe fn sqlite3_db_config( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, - vararg2: &mut i32, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_config.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_config", - " function" - )))(arg1, arg2, vararg1, vararg2) -} - -pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_mutex.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_mutex", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_db_status( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_status", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).extended_errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "extended_errcode", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_log( - arg1: ::std::os::raw::c_int, - arg2: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).log.expect(stringify!( - "sqlite3_api contains null pointer for ", - "log", - " function" - )))(arg1, arg2, vararg1) -} - -pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).soft_heap_limit64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "soft_heap_limit64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sourceid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sourceid", - " function" - )))() -} - -pub unsafe fn sqlite3_stmt_status( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_status", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_strnicmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).strnicmp.expect(stringify!( - "sqlite3_api contains null pointer for ", - "strnicmp", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_unlock_notify( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int), - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).unlock_notify.expect(stringify!( - "sqlite3_api contains null pointer for ", - "unlock_notify", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_wal_autocheckpoint( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_autocheckpoint", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_wal_checkpoint( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_checkpoint.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_checkpoint", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_wal_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_blob_reopen( - arg1: *mut sqlite3_blob, - arg2: sqlite3_int64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_reopen.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_reopen", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vtab_config( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vtab_config.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vtab_config", - " function" - )))(arg1, op, vararg1) -} - -pub unsafe fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vtab_on_conflict.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vtab_on_conflict", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "close_v2", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_db_filename( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_filename.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_filename", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_db_readonly( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_readonly.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_readonly", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_release_memory.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_release_memory", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errstr.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errstr", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_busy.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_busy", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_stmt_readonly(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_readonly.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_readonly", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_stricmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stricmp.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stricmp", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_uri_boolean( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).uri_boolean.expect(stringify!( - "sqlite3_api contains null pointer for ", - "uri_boolean", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_uri_int64( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_int64, -) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).uri_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "uri_int64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_uri_parameter( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).uri_parameter.expect(stringify!( - "sqlite3_api contains null pointer for ", - "uri_parameter", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vsnprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut __va_list_tag, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vsnprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vsnprintf", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_wal_checkpoint_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_checkpoint_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_checkpoint_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_auto_extension( - arg1: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).auto_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "auto_extension", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_blob64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_blob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_blob64", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_bind_text64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - arg6: ::std::os::raw::c_uchar, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text64", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_cancel_auto_extension( - arg1: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).cancel_auto_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "cancel_auto_extension", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_load_extension( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).load_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "load_extension", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_malloc64(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).malloc64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "malloc64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_msize(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).msize.expect(stringify!( - "sqlite3_api contains null pointer for ", - "msize", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_realloc64( - arg1: *mut ::std::os::raw::c_void, - arg2: sqlite3_uint64, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).realloc64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "realloc64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_reset_auto_extension() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).reset_auto_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "reset_auto_extension", - " function" - )))() -} - -pub unsafe fn sqlite3_result_blob64( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_blob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_blob64", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text64( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - arg5: ::std::os::raw::c_uchar, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text64", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_strglob( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).strglob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "strglob", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_value_dup(arg1: *const sqlite3_value) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_dup.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_dup", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_free(arg1: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_zeroblob64( - arg1: *mut sqlite3_context, - arg2: sqlite3_uint64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_zeroblob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_zeroblob64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_zeroblob64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_uint64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_zeroblob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_zeroblob64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_value_subtype(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_subtype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_subtype", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_subtype(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_subtype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_subtype", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_status64( - arg1: ::std::os::raw::c_int, - arg2: *mut sqlite3_int64, - arg3: *mut sqlite3_int64, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).status64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "status64", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_strlike( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_uint, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).strlike.expect(stringify!( - "sqlite3_api contains null pointer for ", - "strlike", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_db_cacheflush(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_cacheflush.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_cacheflush", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_system_errno(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).system_errno.expect(stringify!( - "sqlite3_api contains null pointer for ", - "system_errno", - " function" - )))(arg1) -} diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.13.0.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.13.0.rs deleted file mode 100644 index f375d2efb..000000000 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.13.0.rs +++ /dev/null @@ -1,4954 +0,0 @@ -/* automatically generated by rust-bindgen */ - -pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.13.0\0"; -pub const SQLITE_VERSION_NUMBER: i32 = 3013000; -pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = - b"2016-05-18 10:57:30 fc49f556e48970561d7ab6a2f24fdd7d9eb81ff2\0"; -pub const SQLITE_OK: i32 = 0; -pub const SQLITE_ERROR: i32 = 1; -pub const SQLITE_INTERNAL: i32 = 2; -pub const SQLITE_PERM: i32 = 3; -pub const SQLITE_ABORT: i32 = 4; -pub const SQLITE_BUSY: i32 = 5; -pub const SQLITE_LOCKED: i32 = 6; -pub const SQLITE_NOMEM: i32 = 7; -pub const SQLITE_READONLY: i32 = 8; -pub const SQLITE_INTERRUPT: i32 = 9; -pub const SQLITE_IOERR: i32 = 10; -pub const SQLITE_CORRUPT: i32 = 11; -pub const SQLITE_NOTFOUND: i32 = 12; -pub const SQLITE_FULL: i32 = 13; -pub const SQLITE_CANTOPEN: i32 = 14; -pub const SQLITE_PROTOCOL: i32 = 15; -pub const SQLITE_EMPTY: i32 = 16; -pub const SQLITE_SCHEMA: i32 = 17; -pub const SQLITE_TOOBIG: i32 = 18; -pub const SQLITE_CONSTRAINT: i32 = 19; -pub const SQLITE_MISMATCH: i32 = 20; -pub const SQLITE_MISUSE: i32 = 21; -pub const SQLITE_NOLFS: i32 = 22; -pub const SQLITE_AUTH: i32 = 23; -pub const SQLITE_FORMAT: i32 = 24; -pub const SQLITE_RANGE: i32 = 25; -pub const SQLITE_NOTADB: i32 = 26; -pub const SQLITE_NOTICE: i32 = 27; -pub const SQLITE_WARNING: i32 = 28; -pub const SQLITE_ROW: i32 = 100; -pub const SQLITE_DONE: i32 = 101; -pub const SQLITE_IOERR_READ: i32 = 266; -pub const SQLITE_IOERR_SHORT_READ: i32 = 522; -pub const SQLITE_IOERR_WRITE: i32 = 778; -pub const SQLITE_IOERR_FSYNC: i32 = 1034; -pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; -pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; -pub const SQLITE_IOERR_FSTAT: i32 = 1802; -pub const SQLITE_IOERR_UNLOCK: i32 = 2058; -pub const SQLITE_IOERR_RDLOCK: i32 = 2314; -pub const SQLITE_IOERR_DELETE: i32 = 2570; -pub const SQLITE_IOERR_BLOCKED: i32 = 2826; -pub const SQLITE_IOERR_NOMEM: i32 = 3082; -pub const SQLITE_IOERR_ACCESS: i32 = 3338; -pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; -pub const SQLITE_IOERR_LOCK: i32 = 3850; -pub const SQLITE_IOERR_CLOSE: i32 = 4106; -pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; -pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; -pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; -pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; -pub const SQLITE_IOERR_SHMMAP: i32 = 5386; -pub const SQLITE_IOERR_SEEK: i32 = 5642; -pub const SQLITE_IOERR_DELETE_NOENT: i32 = 5898; -pub const SQLITE_IOERR_MMAP: i32 = 6154; -pub const SQLITE_IOERR_GETTEMPPATH: i32 = 6410; -pub const SQLITE_IOERR_CONVPATH: i32 = 6666; -pub const SQLITE_IOERR_VNODE: i32 = 6922; -pub const SQLITE_IOERR_AUTH: i32 = 7178; -pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; -pub const SQLITE_BUSY_RECOVERY: i32 = 261; -pub const SQLITE_BUSY_SNAPSHOT: i32 = 517; -pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; -pub const SQLITE_CANTOPEN_ISDIR: i32 = 526; -pub const SQLITE_CANTOPEN_FULLPATH: i32 = 782; -pub const SQLITE_CANTOPEN_CONVPATH: i32 = 1038; -pub const SQLITE_CORRUPT_VTAB: i32 = 267; -pub const SQLITE_READONLY_RECOVERY: i32 = 264; -pub const SQLITE_READONLY_CANTLOCK: i32 = 520; -pub const SQLITE_READONLY_ROLLBACK: i32 = 776; -pub const SQLITE_READONLY_DBMOVED: i32 = 1032; -pub const SQLITE_ABORT_ROLLBACK: i32 = 516; -pub const SQLITE_CONSTRAINT_CHECK: i32 = 275; -pub const SQLITE_CONSTRAINT_COMMITHOOK: i32 = 531; -pub const SQLITE_CONSTRAINT_FOREIGNKEY: i32 = 787; -pub const SQLITE_CONSTRAINT_FUNCTION: i32 = 1043; -pub const SQLITE_CONSTRAINT_NOTNULL: i32 = 1299; -pub const SQLITE_CONSTRAINT_PRIMARYKEY: i32 = 1555; -pub const SQLITE_CONSTRAINT_TRIGGER: i32 = 1811; -pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067; -pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323; -pub const SQLITE_CONSTRAINT_ROWID: i32 = 2579; -pub const SQLITE_NOTICE_RECOVER_WAL: i32 = 283; -pub const SQLITE_NOTICE_RECOVER_ROLLBACK: i32 = 539; -pub const SQLITE_WARNING_AUTOINDEX: i32 = 284; -pub const SQLITE_AUTH_USER: i32 = 279; -pub const SQLITE_OPEN_READONLY: i32 = 1; -pub const SQLITE_OPEN_READWRITE: i32 = 2; -pub const SQLITE_OPEN_CREATE: i32 = 4; -pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; -pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; -pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; -pub const SQLITE_OPEN_URI: i32 = 64; -pub const SQLITE_OPEN_MEMORY: i32 = 128; -pub const SQLITE_OPEN_MAIN_DB: i32 = 256; -pub const SQLITE_OPEN_TEMP_DB: i32 = 512; -pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; -pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; -pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; -pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; -pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; -pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; -pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; -pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; -pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; -pub const SQLITE_OPEN_WAL: i32 = 524288; -pub const SQLITE_IOCAP_ATOMIC: i32 = 1; -pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; -pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; -pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; -pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; -pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; -pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; -pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; -pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; -pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; -pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; -pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; -pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE: i32 = 4096; -pub const SQLITE_IOCAP_IMMUTABLE: i32 = 8192; -pub const SQLITE_LOCK_NONE: i32 = 0; -pub const SQLITE_LOCK_SHARED: i32 = 1; -pub const SQLITE_LOCK_RESERVED: i32 = 2; -pub const SQLITE_LOCK_PENDING: i32 = 3; -pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; -pub const SQLITE_SYNC_NORMAL: i32 = 2; -pub const SQLITE_SYNC_FULL: i32 = 3; -pub const SQLITE_SYNC_DATAONLY: i32 = 16; -pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; -pub const SQLITE_FCNTL_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_FCNTL_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_FCNTL_LAST_ERRNO: i32 = 4; -pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; -pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; -pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; -pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; -pub const SQLITE_FCNTL_WIN32_AV_RETRY: i32 = 9; -pub const SQLITE_FCNTL_PERSIST_WAL: i32 = 10; -pub const SQLITE_FCNTL_OVERWRITE: i32 = 11; -pub const SQLITE_FCNTL_VFSNAME: i32 = 12; -pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE: i32 = 13; -pub const SQLITE_FCNTL_PRAGMA: i32 = 14; -pub const SQLITE_FCNTL_BUSYHANDLER: i32 = 15; -pub const SQLITE_FCNTL_TEMPFILENAME: i32 = 16; -pub const SQLITE_FCNTL_MMAP_SIZE: i32 = 18; -pub const SQLITE_FCNTL_TRACE: i32 = 19; -pub const SQLITE_FCNTL_HAS_MOVED: i32 = 20; -pub const SQLITE_FCNTL_SYNC: i32 = 21; -pub const SQLITE_FCNTL_COMMIT_PHASETWO: i32 = 22; -pub const SQLITE_FCNTL_WIN32_SET_HANDLE: i32 = 23; -pub const SQLITE_FCNTL_WAL_BLOCK: i32 = 24; -pub const SQLITE_FCNTL_ZIPVFS: i32 = 25; -pub const SQLITE_FCNTL_RBU: i32 = 26; -pub const SQLITE_FCNTL_VFS_POINTER: i32 = 27; -pub const SQLITE_FCNTL_JOURNAL_POINTER: i32 = 28; -pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_LAST_ERRNO: i32 = 4; -pub const SQLITE_ACCESS_EXISTS: i32 = 0; -pub const SQLITE_ACCESS_READWRITE: i32 = 1; -pub const SQLITE_ACCESS_READ: i32 = 2; -pub const SQLITE_SHM_UNLOCK: i32 = 1; -pub const SQLITE_SHM_LOCK: i32 = 2; -pub const SQLITE_SHM_SHARED: i32 = 4; -pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; -pub const SQLITE_SHM_NLOCK: i32 = 8; -pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; -pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; -pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; -pub const SQLITE_CONFIG_MALLOC: i32 = 4; -pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; -pub const SQLITE_CONFIG_SCRATCH: i32 = 6; -pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; -pub const SQLITE_CONFIG_HEAP: i32 = 8; -pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; -pub const SQLITE_CONFIG_MUTEX: i32 = 10; -pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; -pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; -pub const SQLITE_CONFIG_PCACHE: i32 = 14; -pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; -pub const SQLITE_CONFIG_LOG: i32 = 16; -pub const SQLITE_CONFIG_URI: i32 = 17; -pub const SQLITE_CONFIG_PCACHE2: i32 = 18; -pub const SQLITE_CONFIG_GETPCACHE2: i32 = 19; -pub const SQLITE_CONFIG_COVERING_INDEX_SCAN: i32 = 20; -pub const SQLITE_CONFIG_SQLLOG: i32 = 21; -pub const SQLITE_CONFIG_MMAP_SIZE: i32 = 22; -pub const SQLITE_CONFIG_WIN32_HEAPSIZE: i32 = 23; -pub const SQLITE_CONFIG_PCACHE_HDRSZ: i32 = 24; -pub const SQLITE_CONFIG_PMASZ: i32 = 25; -pub const SQLITE_CONFIG_STMTJRNL_SPILL: i32 = 26; -pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; -pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; -pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; -pub const SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: i32 = 1004; -pub const SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: i32 = 1005; -pub const SQLITE_DENY: i32 = 1; -pub const SQLITE_IGNORE: i32 = 2; -pub const SQLITE_CREATE_INDEX: i32 = 1; -pub const SQLITE_CREATE_TABLE: i32 = 2; -pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; -pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; -pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; -pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; -pub const SQLITE_CREATE_TRIGGER: i32 = 7; -pub const SQLITE_CREATE_VIEW: i32 = 8; -pub const SQLITE_DELETE: i32 = 9; -pub const SQLITE_DROP_INDEX: i32 = 10; -pub const SQLITE_DROP_TABLE: i32 = 11; -pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; -pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; -pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; -pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; -pub const SQLITE_DROP_TRIGGER: i32 = 16; -pub const SQLITE_DROP_VIEW: i32 = 17; -pub const SQLITE_INSERT: i32 = 18; -pub const SQLITE_PRAGMA: i32 = 19; -pub const SQLITE_READ: i32 = 20; -pub const SQLITE_SELECT: i32 = 21; -pub const SQLITE_TRANSACTION: i32 = 22; -pub const SQLITE_UPDATE: i32 = 23; -pub const SQLITE_ATTACH: i32 = 24; -pub const SQLITE_DETACH: i32 = 25; -pub const SQLITE_ALTER_TABLE: i32 = 26; -pub const SQLITE_REINDEX: i32 = 27; -pub const SQLITE_ANALYZE: i32 = 28; -pub const SQLITE_CREATE_VTABLE: i32 = 29; -pub const SQLITE_DROP_VTABLE: i32 = 30; -pub const SQLITE_FUNCTION: i32 = 31; -pub const SQLITE_SAVEPOINT: i32 = 32; -pub const SQLITE_COPY: i32 = 0; -pub const SQLITE_RECURSIVE: i32 = 33; -pub const SQLITE_LIMIT_LENGTH: i32 = 0; -pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; -pub const SQLITE_LIMIT_COLUMN: i32 = 2; -pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; -pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; -pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; -pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; -pub const SQLITE_LIMIT_ATTACHED: i32 = 7; -pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; -pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; -pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; -pub const SQLITE_LIMIT_WORKER_THREADS: i32 = 11; -pub const SQLITE_INTEGER: i32 = 1; -pub const SQLITE_FLOAT: i32 = 2; -pub const SQLITE_BLOB: i32 = 4; -pub const SQLITE_NULL: i32 = 5; -pub const SQLITE_TEXT: i32 = 3; -pub const SQLITE3_TEXT: i32 = 3; -pub const SQLITE_UTF8: i32 = 1; -pub const SQLITE_UTF16LE: i32 = 2; -pub const SQLITE_UTF16BE: i32 = 3; -pub const SQLITE_UTF16: i32 = 4; -pub const SQLITE_ANY: i32 = 5; -pub const SQLITE_UTF16_ALIGNED: i32 = 8; -pub const SQLITE_DETERMINISTIC: i32 = 2048; -pub const SQLITE_INDEX_SCAN_UNIQUE: i32 = 1; -pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; -pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; -pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; -pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; -pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; -pub const SQLITE_INDEX_CONSTRAINT_LIKE: i32 = 65; -pub const SQLITE_INDEX_CONSTRAINT_GLOB: i32 = 66; -pub const SQLITE_INDEX_CONSTRAINT_REGEXP: i32 = 67; -pub const SQLITE_MUTEX_FAST: i32 = 0; -pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; -pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; -pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; -pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; -pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; -pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; -pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; -pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; -pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; -pub const SQLITE_MUTEX_STATIC_APP1: i32 = 8; -pub const SQLITE_MUTEX_STATIC_APP2: i32 = 9; -pub const SQLITE_MUTEX_STATIC_APP3: i32 = 10; -pub const SQLITE_MUTEX_STATIC_VFS1: i32 = 11; -pub const SQLITE_MUTEX_STATIC_VFS2: i32 = 12; -pub const SQLITE_MUTEX_STATIC_VFS3: i32 = 13; -pub const SQLITE_TESTCTRL_FIRST: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; -pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; -pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; -pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; -pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; -pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; -pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; -pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; -pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; -pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; -pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; -pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 17; -pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 18; -pub const SQLITE_TESTCTRL_EXPLAIN_STMT: i32 = 19; -pub const SQLITE_TESTCTRL_NEVER_CORRUPT: i32 = 20; -pub const SQLITE_TESTCTRL_VDBE_COVERAGE: i32 = 21; -pub const SQLITE_TESTCTRL_BYTEORDER: i32 = 22; -pub const SQLITE_TESTCTRL_ISINIT: i32 = 23; -pub const SQLITE_TESTCTRL_SORTER_MMAP: i32 = 24; -pub const SQLITE_TESTCTRL_IMPOSTER: i32 = 25; -pub const SQLITE_TESTCTRL_LAST: i32 = 25; -pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; -pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; -pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; -pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; -pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; -pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; -pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; -pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; -pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; -pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; -pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; -pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; -pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; -pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; -pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; -pub const SQLITE_DBSTATUS_CACHE_HIT: i32 = 7; -pub const SQLITE_DBSTATUS_CACHE_MISS: i32 = 8; -pub const SQLITE_DBSTATUS_CACHE_WRITE: i32 = 9; -pub const SQLITE_DBSTATUS_DEFERRED_FKS: i32 = 10; -pub const SQLITE_DBSTATUS_MAX: i32 = 10; -pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; -pub const SQLITE_STMTSTATUS_SORT: i32 = 2; -pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; -pub const SQLITE_STMTSTATUS_VM_STEP: i32 = 4; -pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; -pub const SQLITE_CHECKPOINT_FULL: i32 = 1; -pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; -pub const SQLITE_CHECKPOINT_TRUNCATE: i32 = 3; -pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; -pub const SQLITE_ROLLBACK: i32 = 1; -pub const SQLITE_FAIL: i32 = 3; -pub const SQLITE_REPLACE: i32 = 5; -pub const SQLITE_SCANSTAT_NLOOP: i32 = 0; -pub const SQLITE_SCANSTAT_NVISIT: i32 = 1; -pub const SQLITE_SCANSTAT_EST: i32 = 2; -pub const SQLITE_SCANSTAT_NAME: i32 = 3; -pub const SQLITE_SCANSTAT_EXPLAIN: i32 = 4; -pub const SQLITE_SCANSTAT_SELECTID: i32 = 5; -pub const NOT_WITHIN: i32 = 0; -pub const PARTLY_WITHIN: i32 = 1; -pub const FULLY_WITHIN: i32 = 2; -pub const FTS5_TOKENIZE_QUERY: i32 = 1; -pub const FTS5_TOKENIZE_PREFIX: i32 = 2; -pub const FTS5_TOKENIZE_DOCUMENT: i32 = 4; -pub const FTS5_TOKENIZE_AUX: i32 = 8; -pub const FTS5_TOKEN_COLOCATED: i32 = 1; -pub type va_list = __builtin_va_list; -pub type __gnuc_va_list = __builtin_va_list; -extern "C" { - #[link_name = "\u{1}sqlite3_version"] - pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; -} -extern "C" { - pub fn sqlite3_libversion() -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_sourceid() -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_libversion_number() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_compileoption_used( - zOptName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_compileoption_get(N: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_threadsafe() -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3 { - _unused: [u8; 0], -} -pub type sqlite_int64 = ::std::os::raw::c_longlong; -pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; -pub type sqlite3_int64 = sqlite_int64; -pub type sqlite3_uint64 = sqlite_uint64; -extern "C" { - pub fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -pub type sqlite3_callback = ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, ->; -extern "C" { - pub fn sqlite3_exec( - arg1: *mut sqlite3, - sql: *const ::std::os::raw::c_char, - callback: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg2: *mut ::std::os::raw::c_void, - errmsg: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_file { - pub pMethods: *const sqlite3_io_methods, -} -#[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_file)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_file)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_file), - "::", - stringify!(pMethods) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_io_methods { - pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xRead: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *mut ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xWrite: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *const ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pSize: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xUnlock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCheckReservedLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileControl: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - op: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xSectorSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xDeviceCharacteristics: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xShmMap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iPg: ::std::os::raw::c_int, - pgsz: ::std::os::raw::c_int, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xShmLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - offset: ::std::os::raw::c_int, - n: ::std::os::raw::c_int, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xShmBarrier: ::std::option::Option, - pub xShmUnmap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - deleteFlag: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iOfst: sqlite3_int64, - iAmt: ::std::os::raw::c_int, - pp: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xUnfetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iOfst: sqlite3_int64, - p: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_io_methods() { - assert_eq!( - ::std::mem::size_of::(), - 152usize, - concat!("Size of: ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xRead) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xWrite) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnlock) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xCheckReservedLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileControl) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSectorSize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ - as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xDeviceCharacteristics) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmMap) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmBarrier) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmUnmap) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnfetch as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnfetch) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex { - _unused: [u8; 0], -} -pub type sqlite3_syscall_ptr = ::std::option::Option; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vfs { - pub iVersion: ::std::os::raw::c_int, - pub szOsFile: ::std::os::raw::c_int, - pub mxPathname: ::std::os::raw::c_int, - pub pNext: *mut sqlite3_vfs, - pub zName: *const ::std::os::raw::c_char, - pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - pOutFlags: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - syncDir: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xAccess: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - flags: ::std::os::raw::c_int, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFullPathname: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - nOut: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xDlOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zFilename: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void, - >, - pub xDlError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zErrMsg: *mut ::std::os::raw::c_char, - ), - >, - pub xDlSym: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ) -> ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ), - >, - >, - pub xDlClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), - >, - pub xRandomness: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSleep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - microseconds: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTime: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, - >, - pub xGetLastError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTimeInt64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xSetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: sqlite3_syscall_ptr, - ) -> ::std::os::raw::c_int, - >, - pub xGetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> sqlite3_syscall_ptr, - >, - pub xNextSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!( - ::std::mem::size_of::(), - 168usize, - concat!("Size of: ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(szOsFile) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(mxPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(zName) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pAppData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xAccess) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xFullPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlSym) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xRandomness) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSleep) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTime) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetLastError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTimeInt64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xNextSystemCall) - ) - ); -} -extern "C" { - pub fn sqlite3_initialize() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_shutdown() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_os_init() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_os_end() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_db_config( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xRoundup: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub pAppData: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!( - ::std::mem::size_of::(), - 64usize, - concat!("Size of: ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xMalloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xFree) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRealloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRoundup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(pAppData) - ) - ); -} -extern "C" { - pub fn sqlite3_extended_result_codes( - arg1: *mut sqlite3, - onoff: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_interrupt(arg1: *mut sqlite3); -} -extern "C" { - pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_busy_handler( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_busy_timeout( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_get_table( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - pazResult: *mut *mut *mut ::std::os::raw::c_char, - pnRow: *mut ::std::os::raw::c_int, - pnColumn: *mut ::std::os::raw::c_int, - pzErrmsg: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char); -} -extern "C" { - pub fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char, ...) - -> *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_vmprintf( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_snprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_vsnprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_malloc64(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_realloc( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_realloc64( - arg1: *mut ::std::os::raw::c_void, - arg2: sqlite3_uint64, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_free(arg1: *mut ::std::os::raw::c_void); -} -extern "C" { - pub fn sqlite3_msize(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64; -} -extern "C" { - pub fn sqlite3_memory_used() -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_randomness(N: ::std::os::raw::c_int, P: *mut ::std::os::raw::c_void); -} -extern "C" { - pub fn sqlite3_set_authorizer( - arg1: *mut sqlite3, - xAuth: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pUserData: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_trace( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_profile( - arg1: *mut sqlite3, - xProfile: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_uint64, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_progress_handler( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, - ); -} -extern "C" { - pub fn sqlite3_open( - filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_open16( - filename: *const ::std::os::raw::c_void, - ppDb: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_open_v2( - filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3, - flags: ::std::os::raw::c_int, - zVfs: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_uri_parameter( - zFilename: *const ::std::os::raw::c_char, - zParam: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_uri_boolean( - zFile: *const ::std::os::raw::c_char, - zParam: *const ::std::os::raw::c_char, - bDefault: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_uri_int64( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_int64, - ) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_extended_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt { - _unused: [u8; 0], -} -extern "C" { - pub fn sqlite3_limit( - arg1: *mut sqlite3, - id: ::std::os::raw::c_int, - newVal: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_prepare( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_prepare_v2( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_prepare16( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_prepare16_v2( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_stmt_readonly(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Mem { - _unused: [u8; 0], -} -pub type sqlite3_value = Mem; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_context { - _unused: [u8; 0], -} -extern "C" { - pub fn sqlite3_bind_blob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_blob64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_double( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_int( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_int64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_int64, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_null( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_text( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_text16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_text64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - encoding: ::std::os::raw::c_uchar, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_value( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_zeroblob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - n: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_zeroblob64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_uint64, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_parameter_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_bind_parameter_index( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_name( - arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_column_name16( - arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_database_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_column_database_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_table_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_column_table_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_origin_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_column_origin_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_decltype( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_column_decltype16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_blob( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_bytes( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_bytes16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64; -} -extern "C" { - pub fn sqlite3_column_int( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_int64( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_column_text( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_uchar; -} -extern "C" { - pub fn sqlite3_column_text16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_type( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_value( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *mut sqlite3_value; -} -extern "C" { - pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function( - db: *mut sqlite3, - zFunctionName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function16( - db: *mut sqlite3, - zFunctionName: *const ::std::os::raw::c_void, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function_v2( - db: *mut sqlite3, - zFunctionName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_transfer_bindings( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_global_recover() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_thread_cleanup(); -} -extern "C" { - pub fn sqlite3_memory_alarm( - arg1: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: sqlite3_int64, - arg3: ::std::os::raw::c_int, - ), - >, - arg2: *mut ::std::os::raw::c_void, - arg3: sqlite3_int64, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64; -} -extern "C" { - pub fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar; -} -extern "C" { - pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_subtype(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint; -} -extern "C" { - pub fn sqlite3_value_dup(arg1: *const sqlite3_value) -> *mut sqlite3_value; -} -extern "C" { - pub fn sqlite3_value_free(arg1: *mut sqlite3_value); -} -extern "C" { - pub fn sqlite3_aggregate_context( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3; -} -extern "C" { - pub fn sqlite3_get_auxdata( - arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_set_auxdata( - arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option, - ); -} -pub type sqlite3_destructor_type = - ::std::option::Option; -extern "C" { - pub fn sqlite3_result_blob( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_blob64( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64); -} -extern "C" { - pub fn sqlite3_result_error( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ); -} -extern "C" { - pub fn sqlite3_result_error16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - ); -} -extern "C" { - pub fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context); -} -extern "C" { - pub fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context); -} -extern "C" { - pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite3_int64); -} -extern "C" { - pub fn sqlite3_result_null(arg1: *mut sqlite3_context); -} -extern "C" { - pub fn sqlite3_result_text( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_text64( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - encoding: ::std::os::raw::c_uchar, - ); -} -extern "C" { - pub fn sqlite3_result_text16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_text16le( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_text16be( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value); -} -extern "C" { - pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, n: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_result_zeroblob64( - arg1: *mut sqlite3_context, - n: sqlite3_uint64, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_result_subtype(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint); -} -extern "C" { - pub fn sqlite3_create_collation( - arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - xCompare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation_v2( - arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - xCompare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation16( - arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_void, - eTextRep: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - xCompare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed16( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; -} -extern "C" { - #[link_name = "\u{1}sqlite3_temp_directory"] - pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; -} -extern "C" { - #[link_name = "\u{1}sqlite3_data_directory"] - pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3; -} -extern "C" { - pub fn sqlite3_db_filename( - db: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_db_readonly( - db: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) -> *mut sqlite3_stmt; -} -extern "C" { - pub fn sqlite3_commit_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_rollback_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_update_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_soft_heap_limit64(N: sqlite3_int64) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_soft_heap_limit(N: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_table_column_metadata( - db: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - zTableName: *const ::std::os::raw::c_char, - zColumnName: *const ::std::os::raw::c_char, - pzDataType: *mut *const ::std::os::raw::c_char, - pzCollSeq: *mut *const ::std::os::raw::c_char, - pNotNull: *mut ::std::os::raw::c_int, - pPrimaryKey: *mut ::std::os::raw::c_int, - pAutoinc: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_load_extension( - db: *mut sqlite3, - zFile: *const ::std::os::raw::c_char, - zProc: *const ::std::os::raw::c_char, - pzErrMsg: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_enable_load_extension( - db: *mut sqlite3, - onoff: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_auto_extension( - xEntryPoint: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_cancel_auto_extension( - xEntryPoint: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_reset_auto_extension(); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xConnect: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xBestIndex: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: *mut sqlite3_index_info, - ) -> ::std::os::raw::c_int, - >, - pub xDisconnect: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xDestroy: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - ppCursor: *mut *mut sqlite3_vtab_cursor, - ) -> ::std::os::raw::c_int, - >, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xFilter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - idxNum: ::std::os::raw::c_int, - idxStr: *const ::std::os::raw::c_char, - argc: ::std::os::raw::c_int, - argv: *mut *mut sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub xNext: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xEof: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - arg2: *mut sqlite3_context, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - pRowid: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xUpdate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - arg4: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xBegin: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xCommit: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xRollback: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xFindFunction: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - nArg: ::std::os::raw::c_int, - zName: *const ::std::os::raw::c_char, - pxFunc: *mut ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - ppArg: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xRename: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - zNew: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSavepoint: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRelease: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRollbackTo: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!( - ::std::mem::size_of::(), - 184usize, - concat!("Size of: ", stringify!(sqlite3_module)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_module)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xConnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBestIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDisconnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFilter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xEof) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xColumn) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xUpdate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBegin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCommit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollback) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFindFunction) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRename) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSavepoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRelease) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollbackTo) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info { - pub nConstraint: ::std::os::raw::c_int, - pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, - pub nOrderBy: ::std::os::raw::c_int, - pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, - pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, - pub idxNum: ::std::os::raw::c_int, - pub idxStr: *mut ::std::os::raw::c_char, - pub needToFreeIdxStr: ::std::os::raw::c_int, - pub orderByConsumed: ::std::os::raw::c_int, - pub estimatedCost: f64, - pub estimatedRows: sqlite3_int64, - pub idxFlags: ::std::os::raw::c_int, - pub colUsed: sqlite3_uint64, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint { - pub iColumn: ::std::os::raw::c_int, - pub op: ::std::os::raw::c_uchar, - pub usable: ::std::os::raw::c_uchar, - pub iTermOffset: ::std::os::raw::c_int, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).op as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(op) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).usable - as *const _ as usize - }, - 5usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(usable) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iTermOffset - as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iTermOffset) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_orderby { - pub iColumn: ::std::os::raw::c_int, - pub desc: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).desc as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(desc) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint_usage { - pub argvIndex: ::std::os::raw::c_int, - pub omit: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).argvIndex - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(argvIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).omit - as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(omit) - ) - ); -} -#[test] -fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!( - ::std::mem::size_of::(), - 96usize, - concat!("Size of: ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nOrderBy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aOrderBy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraintUsage) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxNum) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(needToFreeIdxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(orderByConsumed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedCost as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedCost) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedRows as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedRows) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxFlags as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxFlags) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).colUsed as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(colUsed) - ) - ); -} -extern "C" { - pub fn sqlite3_create_module( - db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - p: *const sqlite3_module, - pClientData: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_module_v2( - db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - p: *const sqlite3_module, - pClientData: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(pModule) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(nRef) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(zErrMsg) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab_cursor { - pub pVtab: *mut sqlite3_vtab, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab_cursor), - "::", - stringify!(pVtab) - ) - ); -} -extern "C" { - pub fn sqlite3_declare_vtab( - arg1: *mut sqlite3, - zSQL: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_overload_function( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob { - _unused: [u8; 0], -} -extern "C" { - pub fn sqlite3_blob_open( - arg1: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - zTable: *const ::std::os::raw::c_char, - zColumn: *const ::std::os::raw::c_char, - iRow: sqlite3_int64, - flags: ::std::os::raw::c_int, - ppBlob: *mut *mut sqlite3_blob, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_blob_reopen( - arg1: *mut sqlite3_blob, - arg2: sqlite3_int64, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_blob_read( - arg1: *mut sqlite3_blob, - Z: *mut ::std::os::raw::c_void, - N: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_blob_write( - arg1: *mut sqlite3_blob, - z: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs; -} -extern "C" { - pub fn sqlite3_vfs_register( - arg1: *mut sqlite3_vfs, - makeDflt: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex; -} -extern "C" { - pub fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex); -} -extern "C" { - pub fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex); -} -extern "C" { - pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexNotheld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexInit as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnd) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexAlloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexFree as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexFree) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexTry) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexLeave) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexHeld) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexNotheld) - ) - ); -} -extern "C" { - pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex; -} -extern "C" { - pub fn sqlite3_file_control( - arg1: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - op: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_status( - op: ::std::os::raw::c_int, - pCurrent: *mut ::std::os::raw::c_int, - pHighwater: *mut ::std::os::raw::c_int, - resetFlag: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_status64( - op: ::std::os::raw::c_int, - pCurrent: *mut sqlite3_int64, - pHighwater: *mut sqlite3_int64, - resetFlag: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_db_status( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - pCur: *mut ::std::os::raw::c_int, - pHiwtr: *mut ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_stmt_status( - arg1: *mut sqlite3_stmt, - op: ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_page { - pub pBuf: *mut ::std::os::raw::c_void, - pub pExtra: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_page() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(sqlite3_pcache_page)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_page)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_page), - "::", - stringify!(pBuf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_page), - "::", - stringify!(pExtra) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods2 { - pub iVersion: ::std::os::raw::c_int, - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - szExtra: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache_page, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut sqlite3_pcache_page, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut sqlite3_pcache_page, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, - pub xShrink: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods2() { - assert_eq!( - ::std::mem::size_of::(), - 104usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iVersion as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDestroy as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xShrink) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods { - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!( - ::std::mem::size_of::(), - 88usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xDestroy) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_backup { - _unused: [u8; 0], -} -extern "C" { - pub fn sqlite3_backup_init( - pDest: *mut sqlite3, - zDestName: *const ::std::os::raw::c_char, - pSource: *mut sqlite3, - zSourceName: *const ::std::os::raw::c_char, - ) -> *mut sqlite3_backup; -} -extern "C" { - pub fn sqlite3_backup_step( - p: *mut sqlite3_backup, - nPage: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_backup_finish(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_backup_remaining(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_backup_pagecount(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_unlock_notify( - pBlocked: *mut sqlite3, - xNotify: ::std::option::Option< - unsafe extern "C" fn( - apArg: *mut *mut ::std::os::raw::c_void, - nArg: ::std::os::raw::c_int, - ), - >, - pNotifyArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_stricmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_strnicmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_strglob( - zGlob: *const ::std::os::raw::c_char, - zStr: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_strlike( - zGlob: *const ::std::os::raw::c_char, - zStr: *const ::std::os::raw::c_char, - cEsc: ::std::os::raw::c_uint, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_log( - iErrCode: ::std::os::raw::c_int, - zFormat: *const ::std::os::raw::c_char, - ... - ); -} -extern "C" { - pub fn sqlite3_wal_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_wal_autocheckpoint( - db: *mut sqlite3, - N: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_wal_checkpoint( - db: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_wal_checkpoint_v2( - db: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - eMode: ::std::os::raw::c_int, - pnLog: *mut ::std::os::raw::c_int, - pnCkpt: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_vtab_config( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_stmt_scanstatus( - pStmt: *mut sqlite3_stmt, - idx: ::std::os::raw::c_int, - iScanStatusOp: ::std::os::raw::c_int, - pOut: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_stmt_scanstatus_reset(arg1: *mut sqlite3_stmt); -} -extern "C" { - pub fn sqlite3_db_cacheflush(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_preupdate_hook( - db: *mut sqlite3, - xPreUpdate: ::std::option::Option< - unsafe extern "C" fn( - pCtx: *mut ::std::os::raw::c_void, - db: *mut sqlite3, - op: ::std::os::raw::c_int, - zDb: *const ::std::os::raw::c_char, - zName: *const ::std::os::raw::c_char, - iKey1: sqlite3_int64, - iKey2: sqlite3_int64, - ), - >, - arg1: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_preupdate_old( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_preupdate_count(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_preupdate_depth(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_preupdate_new( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_system_errno(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_snapshot { - _unused: [u8; 0], -} -extern "C" { - pub fn sqlite3_snapshot_get( - db: *mut sqlite3, - zSchema: *const ::std::os::raw::c_char, - ppSnapshot: *mut *mut sqlite3_snapshot, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_snapshot_open( - db: *mut sqlite3, - zSchema: *const ::std::os::raw::c_char, - pSnapshot: *mut sqlite3_snapshot, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_snapshot_free(arg1: *mut sqlite3_snapshot); -} -extern "C" { - pub fn sqlite3_snapshot_cmp( - p1: *mut sqlite3_snapshot, - p2: *mut sqlite3_snapshot, - ) -> ::std::os::raw::c_int; -} -pub type sqlite3_rtree_dbl = f64; -extern "C" { - pub fn sqlite3_rtree_geometry_callback( - db: *mut sqlite3, - zGeom: *const ::std::os::raw::c_char, - xGeom: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_rtree_geometry, - arg2: ::std::os::raw::c_int, - arg3: *mut sqlite3_rtree_dbl, - arg4: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pContext: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_rtree_geometry { - pub pContext: *mut ::std::os::raw::c_void, - pub nParam: ::std::os::raw::c_int, - pub aParam: *mut sqlite3_rtree_dbl, - pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_rtree_geometry() { - assert_eq!( - ::std::mem::size_of::(), - 40usize, - concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pContext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(nParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(aParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pUser) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(xDelUser) - ) - ); -} -extern "C" { - pub fn sqlite3_rtree_query_callback( - db: *mut sqlite3, - zQueryFunc: *const ::std::os::raw::c_char, - xQueryFunc: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_rtree_query_info) -> ::std::os::raw::c_int, - >, - pContext: *mut ::std::os::raw::c_void, - xDestructor: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_rtree_query_info { - pub pContext: *mut ::std::os::raw::c_void, - pub nParam: ::std::os::raw::c_int, - pub aParam: *mut sqlite3_rtree_dbl, - pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, - pub aCoord: *mut sqlite3_rtree_dbl, - pub anQueue: *mut ::std::os::raw::c_uint, - pub nCoord: ::std::os::raw::c_int, - pub iLevel: ::std::os::raw::c_int, - pub mxLevel: ::std::os::raw::c_int, - pub iRowid: sqlite3_int64, - pub rParentScore: sqlite3_rtree_dbl, - pub eParentWithin: ::std::os::raw::c_int, - pub eWithin: ::std::os::raw::c_int, - pub rScore: sqlite3_rtree_dbl, - pub apSqlParam: *mut *mut sqlite3_value, -} -#[test] -fn bindgen_test_layout_sqlite3_rtree_query_info() { - assert_eq!( - ::std::mem::size_of::(), - 112usize, - concat!("Size of: ", stringify!(sqlite3_rtree_query_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_rtree_query_info)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).pContext as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(pContext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(nParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(aParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(pUser) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDelUser as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(xDelUser) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aCoord as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(aCoord) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).anQueue as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(anQueue) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nCoord as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(nCoord) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iLevel as *const _ as usize }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(iLevel) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mxLevel as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(mxLevel) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iRowid as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(iRowid) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rParentScore as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(rParentScore) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).eParentWithin as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(eParentWithin) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).eWithin as *const _ as usize - }, - 92usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(eWithin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).rScore as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(rScore) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).apSqlParam as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(apSqlParam) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5Context { - _unused: [u8; 0], -} -pub type fts5_extension_function = ::std::option::Option< - unsafe extern "C" fn( - pApi: *const Fts5ExtensionApi, - pFts: *mut Fts5Context, - pCtx: *mut sqlite3_context, - nVal: ::std::os::raw::c_int, - apVal: *mut *mut sqlite3_value, - ), ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5PhraseIter { - pub a: *const ::std::os::raw::c_uchar, - pub b: *const ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_Fts5PhraseIter() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(Fts5PhraseIter)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Fts5PhraseIter)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).a as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Fts5PhraseIter), - "::", - stringify!(a) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).b as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Fts5PhraseIter), - "::", - stringify!(b) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5ExtensionApi { - pub iVersion: ::std::os::raw::c_int, - pub xUserData: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> *mut ::std::os::raw::c_void, - >, - pub xColumnCount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, - >, - pub xRowCount: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pnRow: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xColumnTotalSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pnToken: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTokenize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pText: *const ::std::os::raw::c_char, - nText: ::std::os::raw::c_int, - pCtx: *mut ::std::os::raw::c_void, - xToken: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, - arg6: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseCount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, - >, - pub xPhraseSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xInstCount: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pnInst: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xInst: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iIdx: ::std::os::raw::c_int, - piPhrase: *mut ::std::os::raw::c_int, - piCol: *mut ::std::os::raw::c_int, - piOff: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: - ::std::option::Option sqlite3_int64>, - pub xColumnText: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pz: *mut *const ::std::os::raw::c_char, - pn: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xColumnSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pnToken: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xQueryPhrase: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - pUserData: *mut ::std::os::raw::c_void, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const Fts5ExtensionApi, - arg2: *mut Fts5Context, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub xSetAuxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pAux: *mut ::std::os::raw::c_void, - xDelete: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub xGetAuxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - bClear: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xPhraseFirst: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - arg2: *mut Fts5PhraseIter, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseNext: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - arg2: *mut Fts5PhraseIter, - piCol: *mut ::std::os::raw::c_int, - piOff: *mut ::std::os::raw::c_int, - ), - >, - pub xPhraseFirstColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - arg2: *mut Fts5PhraseIter, - arg3: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseNextColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - arg2: *mut Fts5PhraseIter, - piCol: *mut ::std::os::raw::c_int, - ), - >, -} -#[test] -fn bindgen_test_layout_Fts5ExtensionApi() { - assert_eq!( - ::std::mem::size_of::(), - 160usize, - concat!("Size of: ", stringify!(Fts5ExtensionApi)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Fts5ExtensionApi)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUserData as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xUserData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnCount as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowCount as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xRowCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xColumnTotalSize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnTotalSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xTokenize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseCount as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseSize as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInstCount as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xInstCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInst as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xInst) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnText as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnText) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnSize as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xQueryPhrase as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xQueryPhrase) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSetAuxdata as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xSetAuxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetAuxdata as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xGetAuxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseFirst as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseFirst) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseNext as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseNext) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPhraseFirstColumn as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseFirstColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPhraseNextColumn as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseNextColumn) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5Tokenizer { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct fts5_tokenizer { - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - azArg: *mut *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ppOut: *mut *mut Fts5Tokenizer, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option, - pub xTokenize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Tokenizer, - pCtx: *mut ::std::os::raw::c_void, - flags: ::std::os::raw::c_int, - pText: *const ::std::os::raw::c_char, - nText: ::std::os::raw::c_int, - xToken: ::std::option::Option< - unsafe extern "C" fn( - pCtx: *mut ::std::os::raw::c_void, - tflags: ::std::os::raw::c_int, - pToken: *const ::std::os::raw::c_char, - nToken: ::std::os::raw::c_int, - iStart: ::std::os::raw::c_int, - iEnd: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_fts5_tokenizer() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(fts5_tokenizer)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(fts5_tokenizer)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xTokenize) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct fts5_api { - pub iVersion: ::std::os::raw::c_int, - pub xCreateTokenizer: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - pContext: *mut ::std::os::raw::c_void, - pTokenizer: *mut fts5_tokenizer, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub xFindTokenizer: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - ppContext: *mut *mut ::std::os::raw::c_void, - pTokenizer: *mut fts5_tokenizer, - ) -> ::std::os::raw::c_int, - >, - pub xCreateFunction: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - pContext: *mut ::std::os::raw::c_void, - xFunction: fts5_extension_function, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_fts5_api() { - assert_eq!( - ::std::mem::size_of::(), - 32usize, - concat!("Size of: ", stringify!(fts5_api)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(fts5_api)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreateTokenizer as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xCreateTokenizer) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindTokenizer as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xFindTokenizer) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreateFunction as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xCreateFunction) - ) - ); -} -pub type __builtin_va_list = [__va_list_tag; 1usize]; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct __va_list_tag { - pub gp_offset: ::std::os::raw::c_uint, - pub fp_offset: ::std::os::raw::c_uint, - pub overflow_arg_area: *mut ::std::os::raw::c_void, - pub reg_save_area: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout___va_list_tag() { - assert_eq!( - ::std::mem::size_of::<__va_list_tag>(), - 24usize, - concat!("Size of: ", stringify!(__va_list_tag)) - ); - assert_eq!( - ::std::mem::align_of::<__va_list_tag>(), - 8usize, - concat!("Alignment of ", stringify!(__va_list_tag)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(gp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(fp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(overflow_arg_area) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(reg_save_area) - ) - ); -} diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.26.0-ext-embed.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.26.0-ext-embed.rs deleted file mode 100644 index a8c5a04cd..000000000 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.26.0-ext-embed.rs +++ /dev/null @@ -1,11140 +0,0 @@ -/* automatically generated by rust-bindgen */ - -pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.26.0\0"; -pub const SQLITE_VERSION_NUMBER: i32 = 3026000; -pub const SQLITE_SOURCE_ID: &'static [u8; 85usize] = - b"2018-12-01 12:34:55 bf8c1b2b7a5960c282e543b9c293686dccff272512d08865f4600fb58238b4f9\0"; -pub const SQLITE_OK: i32 = 0; -pub const SQLITE_ERROR: i32 = 1; -pub const SQLITE_INTERNAL: i32 = 2; -pub const SQLITE_PERM: i32 = 3; -pub const SQLITE_ABORT: i32 = 4; -pub const SQLITE_BUSY: i32 = 5; -pub const SQLITE_LOCKED: i32 = 6; -pub const SQLITE_NOMEM: i32 = 7; -pub const SQLITE_READONLY: i32 = 8; -pub const SQLITE_INTERRUPT: i32 = 9; -pub const SQLITE_IOERR: i32 = 10; -pub const SQLITE_CORRUPT: i32 = 11; -pub const SQLITE_NOTFOUND: i32 = 12; -pub const SQLITE_FULL: i32 = 13; -pub const SQLITE_CANTOPEN: i32 = 14; -pub const SQLITE_PROTOCOL: i32 = 15; -pub const SQLITE_EMPTY: i32 = 16; -pub const SQLITE_SCHEMA: i32 = 17; -pub const SQLITE_TOOBIG: i32 = 18; -pub const SQLITE_CONSTRAINT: i32 = 19; -pub const SQLITE_MISMATCH: i32 = 20; -pub const SQLITE_MISUSE: i32 = 21; -pub const SQLITE_NOLFS: i32 = 22; -pub const SQLITE_AUTH: i32 = 23; -pub const SQLITE_FORMAT: i32 = 24; -pub const SQLITE_RANGE: i32 = 25; -pub const SQLITE_NOTADB: i32 = 26; -pub const SQLITE_NOTICE: i32 = 27; -pub const SQLITE_WARNING: i32 = 28; -pub const SQLITE_ROW: i32 = 100; -pub const SQLITE_DONE: i32 = 101; -pub const SQLITE_ERROR_MISSING_COLLSEQ: i32 = 257; -pub const SQLITE_ERROR_RETRY: i32 = 513; -pub const SQLITE_ERROR_SNAPSHOT: i32 = 769; -pub const SQLITE_IOERR_READ: i32 = 266; -pub const SQLITE_IOERR_SHORT_READ: i32 = 522; -pub const SQLITE_IOERR_WRITE: i32 = 778; -pub const SQLITE_IOERR_FSYNC: i32 = 1034; -pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; -pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; -pub const SQLITE_IOERR_FSTAT: i32 = 1802; -pub const SQLITE_IOERR_UNLOCK: i32 = 2058; -pub const SQLITE_IOERR_RDLOCK: i32 = 2314; -pub const SQLITE_IOERR_DELETE: i32 = 2570; -pub const SQLITE_IOERR_BLOCKED: i32 = 2826; -pub const SQLITE_IOERR_NOMEM: i32 = 3082; -pub const SQLITE_IOERR_ACCESS: i32 = 3338; -pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; -pub const SQLITE_IOERR_LOCK: i32 = 3850; -pub const SQLITE_IOERR_CLOSE: i32 = 4106; -pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; -pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; -pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; -pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; -pub const SQLITE_IOERR_SHMMAP: i32 = 5386; -pub const SQLITE_IOERR_SEEK: i32 = 5642; -pub const SQLITE_IOERR_DELETE_NOENT: i32 = 5898; -pub const SQLITE_IOERR_MMAP: i32 = 6154; -pub const SQLITE_IOERR_GETTEMPPATH: i32 = 6410; -pub const SQLITE_IOERR_CONVPATH: i32 = 6666; -pub const SQLITE_IOERR_VNODE: i32 = 6922; -pub const SQLITE_IOERR_AUTH: i32 = 7178; -pub const SQLITE_IOERR_BEGIN_ATOMIC: i32 = 7434; -pub const SQLITE_IOERR_COMMIT_ATOMIC: i32 = 7690; -pub const SQLITE_IOERR_ROLLBACK_ATOMIC: i32 = 7946; -pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; -pub const SQLITE_LOCKED_VTAB: i32 = 518; -pub const SQLITE_BUSY_RECOVERY: i32 = 261; -pub const SQLITE_BUSY_SNAPSHOT: i32 = 517; -pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; -pub const SQLITE_CANTOPEN_ISDIR: i32 = 526; -pub const SQLITE_CANTOPEN_FULLPATH: i32 = 782; -pub const SQLITE_CANTOPEN_CONVPATH: i32 = 1038; -pub const SQLITE_CANTOPEN_DIRTYWAL: i32 = 1294; -pub const SQLITE_CORRUPT_VTAB: i32 = 267; -pub const SQLITE_CORRUPT_SEQUENCE: i32 = 523; -pub const SQLITE_READONLY_RECOVERY: i32 = 264; -pub const SQLITE_READONLY_CANTLOCK: i32 = 520; -pub const SQLITE_READONLY_ROLLBACK: i32 = 776; -pub const SQLITE_READONLY_DBMOVED: i32 = 1032; -pub const SQLITE_READONLY_CANTINIT: i32 = 1288; -pub const SQLITE_READONLY_DIRECTORY: i32 = 1544; -pub const SQLITE_ABORT_ROLLBACK: i32 = 516; -pub const SQLITE_CONSTRAINT_CHECK: i32 = 275; -pub const SQLITE_CONSTRAINT_COMMITHOOK: i32 = 531; -pub const SQLITE_CONSTRAINT_FOREIGNKEY: i32 = 787; -pub const SQLITE_CONSTRAINT_FUNCTION: i32 = 1043; -pub const SQLITE_CONSTRAINT_NOTNULL: i32 = 1299; -pub const SQLITE_CONSTRAINT_PRIMARYKEY: i32 = 1555; -pub const SQLITE_CONSTRAINT_TRIGGER: i32 = 1811; -pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067; -pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323; -pub const SQLITE_CONSTRAINT_ROWID: i32 = 2579; -pub const SQLITE_NOTICE_RECOVER_WAL: i32 = 283; -pub const SQLITE_NOTICE_RECOVER_ROLLBACK: i32 = 539; -pub const SQLITE_WARNING_AUTOINDEX: i32 = 284; -pub const SQLITE_AUTH_USER: i32 = 279; -pub const SQLITE_OK_LOAD_PERMANENTLY: i32 = 256; -pub const SQLITE_OPEN_READONLY: i32 = 1; -pub const SQLITE_OPEN_READWRITE: i32 = 2; -pub const SQLITE_OPEN_CREATE: i32 = 4; -pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; -pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; -pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; -pub const SQLITE_OPEN_URI: i32 = 64; -pub const SQLITE_OPEN_MEMORY: i32 = 128; -pub const SQLITE_OPEN_MAIN_DB: i32 = 256; -pub const SQLITE_OPEN_TEMP_DB: i32 = 512; -pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; -pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; -pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; -pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; -pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; -pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; -pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; -pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; -pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; -pub const SQLITE_OPEN_WAL: i32 = 524288; -pub const SQLITE_IOCAP_ATOMIC: i32 = 1; -pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; -pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; -pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; -pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; -pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; -pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; -pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; -pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; -pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; -pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; -pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; -pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE: i32 = 4096; -pub const SQLITE_IOCAP_IMMUTABLE: i32 = 8192; -pub const SQLITE_IOCAP_BATCH_ATOMIC: i32 = 16384; -pub const SQLITE_LOCK_NONE: i32 = 0; -pub const SQLITE_LOCK_SHARED: i32 = 1; -pub const SQLITE_LOCK_RESERVED: i32 = 2; -pub const SQLITE_LOCK_PENDING: i32 = 3; -pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; -pub const SQLITE_SYNC_NORMAL: i32 = 2; -pub const SQLITE_SYNC_FULL: i32 = 3; -pub const SQLITE_SYNC_DATAONLY: i32 = 16; -pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; -pub const SQLITE_FCNTL_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_FCNTL_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_FCNTL_LAST_ERRNO: i32 = 4; -pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; -pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; -pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; -pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; -pub const SQLITE_FCNTL_WIN32_AV_RETRY: i32 = 9; -pub const SQLITE_FCNTL_PERSIST_WAL: i32 = 10; -pub const SQLITE_FCNTL_OVERWRITE: i32 = 11; -pub const SQLITE_FCNTL_VFSNAME: i32 = 12; -pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE: i32 = 13; -pub const SQLITE_FCNTL_PRAGMA: i32 = 14; -pub const SQLITE_FCNTL_BUSYHANDLER: i32 = 15; -pub const SQLITE_FCNTL_TEMPFILENAME: i32 = 16; -pub const SQLITE_FCNTL_MMAP_SIZE: i32 = 18; -pub const SQLITE_FCNTL_TRACE: i32 = 19; -pub const SQLITE_FCNTL_HAS_MOVED: i32 = 20; -pub const SQLITE_FCNTL_SYNC: i32 = 21; -pub const SQLITE_FCNTL_COMMIT_PHASETWO: i32 = 22; -pub const SQLITE_FCNTL_WIN32_SET_HANDLE: i32 = 23; -pub const SQLITE_FCNTL_WAL_BLOCK: i32 = 24; -pub const SQLITE_FCNTL_ZIPVFS: i32 = 25; -pub const SQLITE_FCNTL_RBU: i32 = 26; -pub const SQLITE_FCNTL_VFS_POINTER: i32 = 27; -pub const SQLITE_FCNTL_JOURNAL_POINTER: i32 = 28; -pub const SQLITE_FCNTL_WIN32_GET_HANDLE: i32 = 29; -pub const SQLITE_FCNTL_PDB: i32 = 30; -pub const SQLITE_FCNTL_BEGIN_ATOMIC_WRITE: i32 = 31; -pub const SQLITE_FCNTL_COMMIT_ATOMIC_WRITE: i32 = 32; -pub const SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE: i32 = 33; -pub const SQLITE_FCNTL_LOCK_TIMEOUT: i32 = 34; -pub const SQLITE_FCNTL_DATA_VERSION: i32 = 35; -pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_LAST_ERRNO: i32 = 4; -pub const SQLITE_ACCESS_EXISTS: i32 = 0; -pub const SQLITE_ACCESS_READWRITE: i32 = 1; -pub const SQLITE_ACCESS_READ: i32 = 2; -pub const SQLITE_SHM_UNLOCK: i32 = 1; -pub const SQLITE_SHM_LOCK: i32 = 2; -pub const SQLITE_SHM_SHARED: i32 = 4; -pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; -pub const SQLITE_SHM_NLOCK: i32 = 8; -pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; -pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; -pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; -pub const SQLITE_CONFIG_MALLOC: i32 = 4; -pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; -pub const SQLITE_CONFIG_SCRATCH: i32 = 6; -pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; -pub const SQLITE_CONFIG_HEAP: i32 = 8; -pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; -pub const SQLITE_CONFIG_MUTEX: i32 = 10; -pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; -pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; -pub const SQLITE_CONFIG_PCACHE: i32 = 14; -pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; -pub const SQLITE_CONFIG_LOG: i32 = 16; -pub const SQLITE_CONFIG_URI: i32 = 17; -pub const SQLITE_CONFIG_PCACHE2: i32 = 18; -pub const SQLITE_CONFIG_GETPCACHE2: i32 = 19; -pub const SQLITE_CONFIG_COVERING_INDEX_SCAN: i32 = 20; -pub const SQLITE_CONFIG_SQLLOG: i32 = 21; -pub const SQLITE_CONFIG_MMAP_SIZE: i32 = 22; -pub const SQLITE_CONFIG_WIN32_HEAPSIZE: i32 = 23; -pub const SQLITE_CONFIG_PCACHE_HDRSZ: i32 = 24; -pub const SQLITE_CONFIG_PMASZ: i32 = 25; -pub const SQLITE_CONFIG_STMTJRNL_SPILL: i32 = 26; -pub const SQLITE_CONFIG_SMALL_MALLOC: i32 = 27; -pub const SQLITE_CONFIG_SORTERREF_SIZE: i32 = 28; -pub const SQLITE_DBCONFIG_MAINDBNAME: i32 = 1000; -pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; -pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; -pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; -pub const SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: i32 = 1004; -pub const SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: i32 = 1005; -pub const SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE: i32 = 1006; -pub const SQLITE_DBCONFIG_ENABLE_QPSG: i32 = 1007; -pub const SQLITE_DBCONFIG_TRIGGER_EQP: i32 = 1008; -pub const SQLITE_DBCONFIG_RESET_DATABASE: i32 = 1009; -pub const SQLITE_DBCONFIG_DEFENSIVE: i32 = 1010; -pub const SQLITE_DBCONFIG_MAX: i32 = 1010; -pub const SQLITE_DENY: i32 = 1; -pub const SQLITE_IGNORE: i32 = 2; -pub const SQLITE_CREATE_INDEX: i32 = 1; -pub const SQLITE_CREATE_TABLE: i32 = 2; -pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; -pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; -pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; -pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; -pub const SQLITE_CREATE_TRIGGER: i32 = 7; -pub const SQLITE_CREATE_VIEW: i32 = 8; -pub const SQLITE_DELETE: i32 = 9; -pub const SQLITE_DROP_INDEX: i32 = 10; -pub const SQLITE_DROP_TABLE: i32 = 11; -pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; -pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; -pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; -pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; -pub const SQLITE_DROP_TRIGGER: i32 = 16; -pub const SQLITE_DROP_VIEW: i32 = 17; -pub const SQLITE_INSERT: i32 = 18; -pub const SQLITE_PRAGMA: i32 = 19; -pub const SQLITE_READ: i32 = 20; -pub const SQLITE_SELECT: i32 = 21; -pub const SQLITE_TRANSACTION: i32 = 22; -pub const SQLITE_UPDATE: i32 = 23; -pub const SQLITE_ATTACH: i32 = 24; -pub const SQLITE_DETACH: i32 = 25; -pub const SQLITE_ALTER_TABLE: i32 = 26; -pub const SQLITE_REINDEX: i32 = 27; -pub const SQLITE_ANALYZE: i32 = 28; -pub const SQLITE_CREATE_VTABLE: i32 = 29; -pub const SQLITE_DROP_VTABLE: i32 = 30; -pub const SQLITE_FUNCTION: i32 = 31; -pub const SQLITE_SAVEPOINT: i32 = 32; -pub const SQLITE_COPY: i32 = 0; -pub const SQLITE_RECURSIVE: i32 = 33; -pub const SQLITE_TRACE_STMT: i32 = 1; -pub const SQLITE_TRACE_PROFILE: i32 = 2; -pub const SQLITE_TRACE_ROW: i32 = 4; -pub const SQLITE_TRACE_CLOSE: i32 = 8; -pub const SQLITE_LIMIT_LENGTH: i32 = 0; -pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; -pub const SQLITE_LIMIT_COLUMN: i32 = 2; -pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; -pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; -pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; -pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; -pub const SQLITE_LIMIT_ATTACHED: i32 = 7; -pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; -pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; -pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; -pub const SQLITE_LIMIT_WORKER_THREADS: i32 = 11; -pub const SQLITE_PREPARE_PERSISTENT: i32 = 1; -pub const SQLITE_PREPARE_NORMALIZE: i32 = 2; -pub const SQLITE_INTEGER: i32 = 1; -pub const SQLITE_FLOAT: i32 = 2; -pub const SQLITE_BLOB: i32 = 4; -pub const SQLITE_NULL: i32 = 5; -pub const SQLITE_TEXT: i32 = 3; -pub const SQLITE3_TEXT: i32 = 3; -pub const SQLITE_UTF8: i32 = 1; -pub const SQLITE_UTF16LE: i32 = 2; -pub const SQLITE_UTF16BE: i32 = 3; -pub const SQLITE_UTF16: i32 = 4; -pub const SQLITE_ANY: i32 = 5; -pub const SQLITE_UTF16_ALIGNED: i32 = 8; -pub const SQLITE_DETERMINISTIC: i32 = 2048; -pub const SQLITE_WIN32_DATA_DIRECTORY_TYPE: i32 = 1; -pub const SQLITE_WIN32_TEMP_DIRECTORY_TYPE: i32 = 2; -pub const SQLITE_INDEX_SCAN_UNIQUE: i32 = 1; -pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; -pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; -pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; -pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; -pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; -pub const SQLITE_INDEX_CONSTRAINT_LIKE: i32 = 65; -pub const SQLITE_INDEX_CONSTRAINT_GLOB: i32 = 66; -pub const SQLITE_INDEX_CONSTRAINT_REGEXP: i32 = 67; -pub const SQLITE_INDEX_CONSTRAINT_NE: i32 = 68; -pub const SQLITE_INDEX_CONSTRAINT_ISNOT: i32 = 69; -pub const SQLITE_INDEX_CONSTRAINT_ISNOTNULL: i32 = 70; -pub const SQLITE_INDEX_CONSTRAINT_ISNULL: i32 = 71; -pub const SQLITE_INDEX_CONSTRAINT_IS: i32 = 72; -pub const SQLITE_INDEX_CONSTRAINT_FUNCTION: i32 = 150; -pub const SQLITE_MUTEX_FAST: i32 = 0; -pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; -pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; -pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; -pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; -pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; -pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; -pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; -pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; -pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; -pub const SQLITE_MUTEX_STATIC_APP1: i32 = 8; -pub const SQLITE_MUTEX_STATIC_APP2: i32 = 9; -pub const SQLITE_MUTEX_STATIC_APP3: i32 = 10; -pub const SQLITE_MUTEX_STATIC_VFS1: i32 = 11; -pub const SQLITE_MUTEX_STATIC_VFS2: i32 = 12; -pub const SQLITE_MUTEX_STATIC_VFS3: i32 = 13; -pub const SQLITE_TESTCTRL_FIRST: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; -pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; -pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; -pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; -pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; -pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; -pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; -pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; -pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; -pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; -pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; -pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 17; -pub const SQLITE_TESTCTRL_INTERNAL_FUNCTIONS: i32 = 17; -pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 18; -pub const SQLITE_TESTCTRL_EXPLAIN_STMT: i32 = 19; -pub const SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD: i32 = 19; -pub const SQLITE_TESTCTRL_NEVER_CORRUPT: i32 = 20; -pub const SQLITE_TESTCTRL_VDBE_COVERAGE: i32 = 21; -pub const SQLITE_TESTCTRL_BYTEORDER: i32 = 22; -pub const SQLITE_TESTCTRL_ISINIT: i32 = 23; -pub const SQLITE_TESTCTRL_SORTER_MMAP: i32 = 24; -pub const SQLITE_TESTCTRL_IMPOSTER: i32 = 25; -pub const SQLITE_TESTCTRL_PARSER_COVERAGE: i32 = 26; -pub const SQLITE_TESTCTRL_LAST: i32 = 26; -pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; -pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; -pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; -pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; -pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; -pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; -pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; -pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; -pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; -pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; -pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; -pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; -pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; -pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; -pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; -pub const SQLITE_DBSTATUS_CACHE_HIT: i32 = 7; -pub const SQLITE_DBSTATUS_CACHE_MISS: i32 = 8; -pub const SQLITE_DBSTATUS_CACHE_WRITE: i32 = 9; -pub const SQLITE_DBSTATUS_DEFERRED_FKS: i32 = 10; -pub const SQLITE_DBSTATUS_CACHE_USED_SHARED: i32 = 11; -pub const SQLITE_DBSTATUS_CACHE_SPILL: i32 = 12; -pub const SQLITE_DBSTATUS_MAX: i32 = 12; -pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; -pub const SQLITE_STMTSTATUS_SORT: i32 = 2; -pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; -pub const SQLITE_STMTSTATUS_VM_STEP: i32 = 4; -pub const SQLITE_STMTSTATUS_REPREPARE: i32 = 5; -pub const SQLITE_STMTSTATUS_RUN: i32 = 6; -pub const SQLITE_STMTSTATUS_MEMUSED: i32 = 99; -pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; -pub const SQLITE_CHECKPOINT_FULL: i32 = 1; -pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; -pub const SQLITE_CHECKPOINT_TRUNCATE: i32 = 3; -pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; -pub const SQLITE_ROLLBACK: i32 = 1; -pub const SQLITE_FAIL: i32 = 3; -pub const SQLITE_REPLACE: i32 = 5; -pub const SQLITE_SCANSTAT_NLOOP: i32 = 0; -pub const SQLITE_SCANSTAT_NVISIT: i32 = 1; -pub const SQLITE_SCANSTAT_EST: i32 = 2; -pub const SQLITE_SCANSTAT_NAME: i32 = 3; -pub const SQLITE_SCANSTAT_EXPLAIN: i32 = 4; -pub const SQLITE_SCANSTAT_SELECTID: i32 = 5; -pub const SQLITE_SERIALIZE_NOCOPY: i32 = 1; -pub const SQLITE_DESERIALIZE_FREEONCLOSE: i32 = 1; -pub const SQLITE_DESERIALIZE_RESIZEABLE: i32 = 2; -pub const SQLITE_DESERIALIZE_READONLY: i32 = 4; -pub const NOT_WITHIN: i32 = 0; -pub const PARTLY_WITHIN: i32 = 1; -pub const FULLY_WITHIN: i32 = 2; -pub const FTS5_TOKENIZE_QUERY: i32 = 1; -pub const FTS5_TOKENIZE_PREFIX: i32 = 2; -pub const FTS5_TOKENIZE_DOCUMENT: i32 = 4; -pub const FTS5_TOKENIZE_AUX: i32 = 8; -pub const FTS5_TOKEN_COLOCATED: i32 = 1; -pub type va_list = __builtin_va_list; -pub type __gnuc_va_list = __builtin_va_list; -extern "C" { - #[link_name = "\u{1}sqlite3_version"] - pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3 { - _unused: [u8; 0], -} -pub type sqlite_int64 = ::std::os::raw::c_longlong; -pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; -pub type sqlite3_int64 = sqlite_int64; -pub type sqlite3_uint64 = sqlite_uint64; -pub type sqlite3_callback = ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_file { - pub pMethods: *const sqlite3_io_methods, -} -#[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_file)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_file)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_file), - "::", - stringify!(pMethods) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_io_methods { - pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xRead: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *mut ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xWrite: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *const ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pSize: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xUnlock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCheckReservedLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileControl: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - op: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xSectorSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xDeviceCharacteristics: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xShmMap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iPg: ::std::os::raw::c_int, - pgsz: ::std::os::raw::c_int, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xShmLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - offset: ::std::os::raw::c_int, - n: ::std::os::raw::c_int, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xShmBarrier: ::std::option::Option, - pub xShmUnmap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - deleteFlag: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iOfst: sqlite3_int64, - iAmt: ::std::os::raw::c_int, - pp: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xUnfetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iOfst: sqlite3_int64, - p: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_io_methods() { - assert_eq!( - ::std::mem::size_of::(), - 152usize, - concat!("Size of: ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xRead) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xWrite) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnlock) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xCheckReservedLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileControl) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSectorSize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ - as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xDeviceCharacteristics) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmMap) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmBarrier) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmUnmap) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnfetch as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnfetch) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex { - _unused: [u8; 0], -} -pub type sqlite3_syscall_ptr = ::std::option::Option; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vfs { - pub iVersion: ::std::os::raw::c_int, - pub szOsFile: ::std::os::raw::c_int, - pub mxPathname: ::std::os::raw::c_int, - pub pNext: *mut sqlite3_vfs, - pub zName: *const ::std::os::raw::c_char, - pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - pOutFlags: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - syncDir: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xAccess: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - flags: ::std::os::raw::c_int, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFullPathname: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - nOut: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xDlOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zFilename: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void, - >, - pub xDlError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zErrMsg: *mut ::std::os::raw::c_char, - ), - >, - pub xDlSym: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ) -> ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ), - >, - >, - pub xDlClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), - >, - pub xRandomness: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSleep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - microseconds: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTime: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, - >, - pub xGetLastError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTimeInt64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xSetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: sqlite3_syscall_ptr, - ) -> ::std::os::raw::c_int, - >, - pub xGetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> sqlite3_syscall_ptr, - >, - pub xNextSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!( - ::std::mem::size_of::(), - 168usize, - concat!("Size of: ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(szOsFile) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(mxPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(zName) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pAppData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xAccess) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xFullPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlSym) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xRandomness) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSleep) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTime) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetLastError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTimeInt64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xNextSystemCall) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xRoundup: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub pAppData: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!( - ::std::mem::size_of::(), - 64usize, - concat!("Size of: ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xMalloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xFree) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRealloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRoundup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(pAppData) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_value { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_context { - _unused: [u8; 0], -} -pub type sqlite3_destructor_type = - ::std::option::Option; -extern "C" { - #[link_name = "\u{1}sqlite3_temp_directory"] - pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; -} -extern "C" { - #[link_name = "\u{1}sqlite3_data_directory"] - pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xConnect: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xBestIndex: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: *mut sqlite3_index_info, - ) -> ::std::os::raw::c_int, - >, - pub xDisconnect: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xDestroy: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - ppCursor: *mut *mut sqlite3_vtab_cursor, - ) -> ::std::os::raw::c_int, - >, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xFilter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - idxNum: ::std::os::raw::c_int, - idxStr: *const ::std::os::raw::c_char, - argc: ::std::os::raw::c_int, - argv: *mut *mut sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub xNext: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xEof: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - arg2: *mut sqlite3_context, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - pRowid: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xUpdate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - arg4: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xBegin: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xCommit: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xRollback: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xFindFunction: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - nArg: ::std::os::raw::c_int, - zName: *const ::std::os::raw::c_char, - pxFunc: *mut ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - ppArg: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xRename: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - zNew: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSavepoint: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRelease: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRollbackTo: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xShadowName: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!( - ::std::mem::size_of::(), - 192usize, - concat!("Size of: ", stringify!(sqlite3_module)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_module)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xConnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBestIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDisconnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFilter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xEof) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xColumn) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xUpdate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBegin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCommit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollback) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFindFunction) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRename) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSavepoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRelease) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollbackTo) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShadowName as *const _ as usize }, - 184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xShadowName) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info { - pub nConstraint: ::std::os::raw::c_int, - pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, - pub nOrderBy: ::std::os::raw::c_int, - pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, - pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, - pub idxNum: ::std::os::raw::c_int, - pub idxStr: *mut ::std::os::raw::c_char, - pub needToFreeIdxStr: ::std::os::raw::c_int, - pub orderByConsumed: ::std::os::raw::c_int, - pub estimatedCost: f64, - pub estimatedRows: sqlite3_int64, - pub idxFlags: ::std::os::raw::c_int, - pub colUsed: sqlite3_uint64, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint { - pub iColumn: ::std::os::raw::c_int, - pub op: ::std::os::raw::c_uchar, - pub usable: ::std::os::raw::c_uchar, - pub iTermOffset: ::std::os::raw::c_int, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).op as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(op) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).usable - as *const _ as usize - }, - 5usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(usable) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iTermOffset - as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iTermOffset) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_orderby { - pub iColumn: ::std::os::raw::c_int, - pub desc: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).desc as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(desc) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint_usage { - pub argvIndex: ::std::os::raw::c_int, - pub omit: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).argvIndex - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(argvIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).omit - as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(omit) - ) - ); -} -#[test] -fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!( - ::std::mem::size_of::(), - 96usize, - concat!("Size of: ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nOrderBy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aOrderBy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraintUsage) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxNum) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(needToFreeIdxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(orderByConsumed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedCost as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedCost) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedRows as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedRows) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxFlags as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxFlags) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).colUsed as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(colUsed) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(pModule) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(nRef) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(zErrMsg) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab_cursor { - pub pVtab: *mut sqlite3_vtab, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab_cursor), - "::", - stringify!(pVtab) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexNotheld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexInit as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnd) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexAlloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexFree as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexFree) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexTry) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexLeave) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexHeld) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexNotheld) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_str { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_page { - pub pBuf: *mut ::std::os::raw::c_void, - pub pExtra: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_page() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(sqlite3_pcache_page)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_page)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_page), - "::", - stringify!(pBuf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_page), - "::", - stringify!(pExtra) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods2 { - pub iVersion: ::std::os::raw::c_int, - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - szExtra: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache_page, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut sqlite3_pcache_page, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut sqlite3_pcache_page, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, - pub xShrink: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods2() { - assert_eq!( - ::std::mem::size_of::(), - 104usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iVersion as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDestroy as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xShrink) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods { - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!( - ::std::mem::size_of::(), - 88usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xDestroy) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_backup { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct sqlite3_snapshot { - pub hidden: [::std::os::raw::c_uchar; 48usize], -} -#[test] -fn bindgen_test_layout_sqlite3_snapshot() { - assert_eq!( - ::std::mem::size_of::(), - 48usize, - concat!("Size of: ", stringify!(sqlite3_snapshot)) - ); - assert_eq!( - ::std::mem::align_of::(), - 1usize, - concat!("Alignment of ", stringify!(sqlite3_snapshot)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).hidden as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_snapshot), - "::", - stringify!(hidden) - ) - ); -} -pub type sqlite3_rtree_dbl = f64; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_rtree_geometry { - pub pContext: *mut ::std::os::raw::c_void, - pub nParam: ::std::os::raw::c_int, - pub aParam: *mut sqlite3_rtree_dbl, - pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_rtree_geometry() { - assert_eq!( - ::std::mem::size_of::(), - 40usize, - concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pContext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(nParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(aParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pUser) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(xDelUser) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_rtree_query_info { - pub pContext: *mut ::std::os::raw::c_void, - pub nParam: ::std::os::raw::c_int, - pub aParam: *mut sqlite3_rtree_dbl, - pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, - pub aCoord: *mut sqlite3_rtree_dbl, - pub anQueue: *mut ::std::os::raw::c_uint, - pub nCoord: ::std::os::raw::c_int, - pub iLevel: ::std::os::raw::c_int, - pub mxLevel: ::std::os::raw::c_int, - pub iRowid: sqlite3_int64, - pub rParentScore: sqlite3_rtree_dbl, - pub eParentWithin: ::std::os::raw::c_int, - pub eWithin: ::std::os::raw::c_int, - pub rScore: sqlite3_rtree_dbl, - pub apSqlParam: *mut *mut sqlite3_value, -} -#[test] -fn bindgen_test_layout_sqlite3_rtree_query_info() { - assert_eq!( - ::std::mem::size_of::(), - 112usize, - concat!("Size of: ", stringify!(sqlite3_rtree_query_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_rtree_query_info)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).pContext as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(pContext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(nParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(aParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(pUser) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDelUser as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(xDelUser) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aCoord as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(aCoord) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).anQueue as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(anQueue) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nCoord as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(nCoord) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iLevel as *const _ as usize }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(iLevel) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mxLevel as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(mxLevel) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iRowid as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(iRowid) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rParentScore as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(rParentScore) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).eParentWithin as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(eParentWithin) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).eWithin as *const _ as usize - }, - 92usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(eWithin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).rScore as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(rScore) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).apSqlParam as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(apSqlParam) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5Context { - _unused: [u8; 0], -} -pub type fts5_extension_function = ::std::option::Option< - unsafe extern "C" fn( - pApi: *const Fts5ExtensionApi, - pFts: *mut Fts5Context, - pCtx: *mut sqlite3_context, - nVal: ::std::os::raw::c_int, - apVal: *mut *mut sqlite3_value, - ), ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5PhraseIter { - pub a: *const ::std::os::raw::c_uchar, - pub b: *const ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_Fts5PhraseIter() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(Fts5PhraseIter)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Fts5PhraseIter)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).a as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Fts5PhraseIter), - "::", - stringify!(a) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).b as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Fts5PhraseIter), - "::", - stringify!(b) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5ExtensionApi { - pub iVersion: ::std::os::raw::c_int, - pub xUserData: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> *mut ::std::os::raw::c_void, - >, - pub xColumnCount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, - >, - pub xRowCount: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pnRow: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xColumnTotalSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pnToken: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTokenize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pText: *const ::std::os::raw::c_char, - nText: ::std::os::raw::c_int, - pCtx: *mut ::std::os::raw::c_void, - xToken: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, - arg6: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseCount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, - >, - pub xPhraseSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xInstCount: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pnInst: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xInst: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iIdx: ::std::os::raw::c_int, - piPhrase: *mut ::std::os::raw::c_int, - piCol: *mut ::std::os::raw::c_int, - piOff: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: - ::std::option::Option sqlite3_int64>, - pub xColumnText: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pz: *mut *const ::std::os::raw::c_char, - pn: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xColumnSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pnToken: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xQueryPhrase: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - pUserData: *mut ::std::os::raw::c_void, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const Fts5ExtensionApi, - arg2: *mut Fts5Context, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub xSetAuxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pAux: *mut ::std::os::raw::c_void, - xDelete: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub xGetAuxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - bClear: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xPhraseFirst: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - arg2: *mut Fts5PhraseIter, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseNext: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - arg2: *mut Fts5PhraseIter, - piCol: *mut ::std::os::raw::c_int, - piOff: *mut ::std::os::raw::c_int, - ), - >, - pub xPhraseFirstColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - arg2: *mut Fts5PhraseIter, - arg3: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseNextColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - arg2: *mut Fts5PhraseIter, - piCol: *mut ::std::os::raw::c_int, - ), - >, -} -#[test] -fn bindgen_test_layout_Fts5ExtensionApi() { - assert_eq!( - ::std::mem::size_of::(), - 160usize, - concat!("Size of: ", stringify!(Fts5ExtensionApi)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Fts5ExtensionApi)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUserData as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xUserData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnCount as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowCount as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xRowCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xColumnTotalSize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnTotalSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xTokenize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseCount as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseSize as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInstCount as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xInstCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInst as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xInst) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnText as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnText) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnSize as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xQueryPhrase as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xQueryPhrase) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSetAuxdata as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xSetAuxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetAuxdata as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xGetAuxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseFirst as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseFirst) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseNext as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseNext) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPhraseFirstColumn as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseFirstColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPhraseNextColumn as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseNextColumn) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5Tokenizer { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct fts5_tokenizer { - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - azArg: *mut *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ppOut: *mut *mut Fts5Tokenizer, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option, - pub xTokenize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Tokenizer, - pCtx: *mut ::std::os::raw::c_void, - flags: ::std::os::raw::c_int, - pText: *const ::std::os::raw::c_char, - nText: ::std::os::raw::c_int, - xToken: ::std::option::Option< - unsafe extern "C" fn( - pCtx: *mut ::std::os::raw::c_void, - tflags: ::std::os::raw::c_int, - pToken: *const ::std::os::raw::c_char, - nToken: ::std::os::raw::c_int, - iStart: ::std::os::raw::c_int, - iEnd: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_fts5_tokenizer() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(fts5_tokenizer)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(fts5_tokenizer)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xTokenize) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct fts5_api { - pub iVersion: ::std::os::raw::c_int, - pub xCreateTokenizer: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - pContext: *mut ::std::os::raw::c_void, - pTokenizer: *mut fts5_tokenizer, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub xFindTokenizer: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - ppContext: *mut *mut ::std::os::raw::c_void, - pTokenizer: *mut fts5_tokenizer, - ) -> ::std::os::raw::c_int, - >, - pub xCreateFunction: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - pContext: *mut ::std::os::raw::c_void, - xFunction: fts5_extension_function, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_fts5_api() { - assert_eq!( - ::std::mem::size_of::(), - 32usize, - concat!("Size of: ", stringify!(fts5_api)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(fts5_api)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreateTokenizer as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xCreateTokenizer) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindTokenizer as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xFindTokenizer) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreateFunction as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xCreateFunction) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_api_routines { - pub aggregate_context: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub aggregate_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, - >, - pub bind_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_double: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, - ) -> ::std::os::raw::c_int, - >, - pub bind_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_int64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, - ) -> ::std::os::raw::c_int, - >, - pub bind_null: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub bind_parameter_index: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub bind_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub busy_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub busy_timeout: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub changes: - ::std::option::Option ::std::os::raw::c_int>, - pub close: - ::std::option::Option ::std::os::raw::c_int>, - pub collation_needed: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub collation_needed16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub column_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_bytes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_bytes16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub column_database_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_database_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_decltype: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_decltype16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_double: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, - >, - pub column_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_int64: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, - >, - pub column_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_origin_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_origin_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_table_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_table_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_uchar, - >, - pub column_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_type: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *mut sqlite3_value, - >, - pub commit_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub complete: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, - pub complete16: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub create_collation: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_collation16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_function16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_module: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub data_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub db_handle: - ::std::option::Option *mut sqlite3>, - pub declare_vtab: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub enable_shared_cache: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub errcode: - ::std::option::Option ::std::os::raw::c_int>, - pub errmsg: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, - >, - pub errmsg16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, - >, - pub exec: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub expired: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub finalize: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub free: ::std::option::Option, - pub free_table: - ::std::option::Option, - pub get_autocommit: - ::std::option::Option ::std::os::raw::c_int>, - pub get_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub get_table: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub global_recover: ::std::option::Option ::std::os::raw::c_int>, - pub interruptx: ::std::option::Option, - pub last_insert_rowid: - ::std::option::Option sqlite_int64>, - pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, - pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, - pub malloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub mprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub open16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub prepare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub profile: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub progress_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, - ), - >, - pub realloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub reset: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub result_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_double: - ::std::option::Option, - pub result_error: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_error16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_int64: - ::std::option::Option, - pub result_null: ::std::option::Option, - pub result_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16be: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16le: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_value: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), - >, - pub rollback_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub set_authorizer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub set_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, - ), - >, - pub xsnprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub step: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub table_column_metadata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub thread_cleanup: ::std::option::Option, - pub total_changes: - ::std::option::Option ::std::os::raw::c_int>, - pub trace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub transfer_bindings: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, - ) -> ::std::os::raw::c_int, - >, - pub update_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub user_data: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, - >, - pub value_blob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_bytes16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_double: ::std::option::Option f64>, - pub value_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_int64: - ::std::option::Option sqlite_int64>, - pub value_numeric_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_text: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, - >, - pub value_text16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16be: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16le: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub vmprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char, - >, - pub overload_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub prepare_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub clear_bindings: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub create_module_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_zeroblob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_close: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, - ) -> ::std::os::raw::c_int, - >, - pub blob_read: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_write: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub create_collation_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub file_control: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub memory_highwater: - ::std::option::Option sqlite3_int64>, - pub memory_used: ::std::option::Option sqlite3_int64>, - pub mutex_alloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub mutex_enter: ::std::option::Option, - pub mutex_free: ::std::option::Option, - pub mutex_leave: ::std::option::Option, - pub mutex_try: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub open_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub release_memory: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub result_error_nomem: ::std::option::Option, - pub result_error_toobig: - ::std::option::Option, - pub sleep: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub soft_heap_limit: ::std::option::Option, - pub vfs_find: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, - >, - pub vfs_register: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub vfs_unregister: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, - >, - pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, - pub result_zeroblob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_error_code: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub test_control: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, - >, - pub randomness: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), - >, - pub context_db_handle: - ::std::option::Option *mut sqlite3>, - pub extended_result_codes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub limit: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub next_stmt: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, - >, - pub sql: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, - >, - pub status: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub backup_finish: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_init: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut sqlite3, - arg4: *const ::std::os::raw::c_char, - ) -> *mut sqlite3_backup, - >, - pub backup_pagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_remaining: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_step: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_backup, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub compileoption_get: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, - >, - pub compileoption_used: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, - pub create_function_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub db_config: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int, - >, - pub db_mutex: - ::std::option::Option *mut sqlite3_mutex>, - pub db_status: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub extended_errcode: - ::std::option::Option ::std::os::raw::c_int>, - pub log: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char, ...), - >, - pub soft_heap_limit64: - ::std::option::Option sqlite3_int64>, - pub sourceid: ::std::option::Option *const ::std::os::raw::c_char>, - pub stmt_status: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub strnicmp: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub unlock_notify: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub wal_autocheckpoint: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub wal_checkpoint: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub wal_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub blob_reopen: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob, arg2: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub vtab_config: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int, - >, - pub vtab_on_conflict: - ::std::option::Option ::std::os::raw::c_int>, - pub close_v2: - ::std::option::Option ::std::os::raw::c_int>, - pub db_filename: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, - pub db_readonly: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub db_release_memory: - ::std::option::Option ::std::os::raw::c_int>, - pub errstr: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, - >, - pub stmt_busy: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub stmt_readonly: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub stricmp: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub uri_boolean: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub uri_int64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_int64, - ) -> sqlite3_int64, - >, - pub uri_parameter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, - pub xvsnprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char, - >, - pub wal_checkpoint_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub auto_extension: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_blob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_text64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - arg6: ::std::os::raw::c_uchar, - ) -> ::std::os::raw::c_int, - >, - pub cancel_auto_extension: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub load_extension: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub malloc64: ::std::option::Option< - unsafe extern "C" fn(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void, - >, - pub msize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64, - >, - pub realloc64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: sqlite3_uint64, - ) -> *mut ::std::os::raw::c_void, - >, - pub reset_auto_extension: ::std::option::Option, - pub result_blob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - ), - >, - pub result_text64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - arg5: ::std::os::raw::c_uchar, - ), - >, - pub strglob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub value_dup: ::std::option::Option< - unsafe extern "C" fn(arg1: *const sqlite3_value) -> *mut sqlite3_value, - >, - pub value_free: ::std::option::Option, - pub result_zeroblob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: sqlite3_uint64, - ) -> ::std::os::raw::c_int, - >, - pub bind_zeroblob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_uint64, - ) -> ::std::os::raw::c_int, - >, - pub value_subtype: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint, - >, - pub result_subtype: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint), - >, - pub status64: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut sqlite3_int64, - arg3: *mut sqlite3_int64, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub strlike: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_uint, - ) -> ::std::os::raw::c_int, - >, - pub db_cacheflush: - ::std::option::Option ::std::os::raw::c_int>, - pub system_errno: - ::std::option::Option ::std::os::raw::c_int>, - pub trace_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_uint, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_uint, - arg2: *mut ::std::os::raw::c_void, - arg3: *mut ::std::os::raw::c_void, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub expanded_sql: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char, - >, - pub set_last_insert_rowid: - ::std::option::Option, - pub prepare_v3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_uint, - arg5: *mut *mut sqlite3_stmt, - arg6: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16_v3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_uint, - arg5: *mut *mut sqlite3_stmt, - arg6: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub bind_pointer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: *const ::std::os::raw::c_char, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub result_pointer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *mut ::std::os::raw::c_void, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::option::Option, - ), - >, - pub value_pointer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_value, - arg2: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void, - >, - pub vtab_nochange: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, - >, - pub value_nochange: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub vtab_collation: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_index_info, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub keyword_count: ::std::option::Option ::std::os::raw::c_int>, - pub keyword_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut *const ::std::os::raw::c_char, - arg3: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub keyword_check: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub str_new: - ::std::option::Option *mut sqlite3_str>, - pub str_finish: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char, - >, - pub str_appendf: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_str, zFormat: *const ::std::os::raw::c_char, ...), - >, - pub str_vappendf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_str, - zFormat: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, - ), - >, - pub str_append: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_str, - zIn: *const ::std::os::raw::c_char, - N: ::std::os::raw::c_int, - ), - >, - pub str_appendall: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_str, zIn: *const ::std::os::raw::c_char), - >, - pub str_appendchar: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_str, - N: ::std::os::raw::c_int, - C: ::std::os::raw::c_char, - ), - >, - pub str_reset: ::std::option::Option, - pub str_errcode: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int, - >, - pub str_length: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int, - >, - pub str_value: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char, - >, - pub create_window_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xValue: ::std::option::Option, - xInv: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub normalized_sql: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_api_routines() { - assert_eq!( - ::std::mem::size_of::(), - 1928usize, - concat!("Size of: ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_context as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_context) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_count as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_double as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_count as *const _ - as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_index as *const _ - as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_index) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_name as *const _ - as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_text16 as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_handler as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_handler) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_timeout as *const _ as usize - }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_timeout) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(close) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed as *const _ as usize - }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_blob as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes as *const _ as usize - }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize - }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_count as *const _ as usize - }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name as *const _ - as usize - }, - 184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name16 as *const _ - as usize - }, - 192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype as *const _ as usize - }, - 200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize - }, - 208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_double as *const _ as usize - }, - 216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, - 224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_int64 as *const _ as usize - }, - 232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name as *const _ as usize - }, - 240usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name16 as *const _ as usize - }, - 248usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name as *const _ as usize - }, - 256usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name16 as *const _ - as usize - }, - 264usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name as *const _ as usize - }, - 272usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name16 as *const _ - as usize - }, - 280usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text as *const _ as usize - }, - 288usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text16 as *const _ as usize - }, - 296usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_type as *const _ as usize - }, - 304usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_type) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_value as *const _ as usize - }, - 312usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).commit_hook as *const _ as usize - }, - 320usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(commit_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, - 328usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, - 336usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation as *const _ as usize - }, - 344usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation16 as *const _ as usize - }, - 352usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function as *const _ as usize - }, - 360usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function16 as *const _ as usize - }, - 368usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module as *const _ as usize - }, - 376usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, - 384usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(data_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, - 392usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).declare_vtab as *const _ as usize - }, - 400usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(declare_vtab) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).enable_shared_cache as *const _ - as usize - }, - 408usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(enable_shared_cache) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, - 416usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, - 424usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, - 432usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, - 440usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(exec) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, - 448usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(expired) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, - 456usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(finalize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, - 464usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, - 472usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_autocommit as *const _ as usize - }, - 480usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_autocommit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_auxdata as *const _ as usize - }, - 488usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, - 496usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).global_recover as *const _ as usize - }, - 504usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(global_recover) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, - 512usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(interruptx) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize - }, - 520usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(last_insert_rowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, - 528usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).libversion_number as *const _ as usize - }, - 536usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion_number) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, - 544usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(malloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, - 552usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, - 560usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, - 568usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, - 576usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, - 584usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, - 592usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(profile) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).progress_handler as *const _ as usize - }, - 600usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(progress_handler) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, - 608usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(realloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, - 616usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(reset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_blob as *const _ as usize - }, - 624usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_double as *const _ as usize - }, - 632usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_double) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error as *const _ as usize - }, - 640usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error16 as *const _ as usize - }, - 648usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, - 656usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_int64 as *const _ as usize - }, - 664usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_null as *const _ as usize - }, - 672usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text as *const _ as usize - }, - 680usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16 as *const _ as usize - }, - 688usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16be as *const _ as usize - }, - 696usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16le as *const _ as usize - }, - 704usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16le) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_value as *const _ as usize - }, - 712usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rollback_hook as *const _ as usize - }, - 720usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(rollback_hook) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_authorizer as *const _ as usize - }, - 728usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_authorizer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_auxdata as *const _ as usize - }, - 736usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xsnprintf as *const _ as usize }, - 744usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(xsnprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, - 752usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(step) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).table_column_metadata as *const _ - as usize - }, - 760usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(table_column_metadata) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize - }, - 768usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(thread_cleanup) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).total_changes as *const _ as usize - }, - 776usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(total_changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, - 784usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(trace) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize - }, - 792usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(transfer_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).update_hook as *const _ as usize - }, - 800usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(update_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, - 808usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(user_data) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, - 816usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes as *const _ as usize - }, - 824usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize - }, - 832usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_double as *const _ as usize - }, - 840usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, - 848usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_int64 as *const _ as usize - }, - 856usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize - }, - 864usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_numeric_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, - 872usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16 as *const _ as usize - }, - 880usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16be as *const _ as usize - }, - 888usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16le as *const _ as usize - }, - 896usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16le) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, - 904usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, - 912usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vmprintf) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).overload_function as *const _ as usize - }, - 920usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(overload_function) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, - 928usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize - }, - 936usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).clear_bindings as *const _ as usize - }, - 944usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(clear_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize - }, - 952usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize - }, - 960usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_zeroblob) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, - 968usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_bytes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, - 976usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_close) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, - 984usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, - 992usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_read) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, - 1000usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_write) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation_v2 as *const _ - as usize - }, - 1008usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).file_control as *const _ as usize - }, - 1016usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(file_control) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_highwater as *const _ as usize - }, - 1024usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_highwater) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_used as *const _ as usize - }, - 1032usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_used) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize - }, - 1040usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_alloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_enter as *const _ as usize - }, - 1048usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_enter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, - 1056usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_free) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_leave as *const _ as usize - }, - 1064usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_leave) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, - 1072usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_try) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, - 1080usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).release_memory as *const _ as usize - }, - 1088usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(release_memory) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize - }, - 1096usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_nomem) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_toobig as *const _ - as usize - }, - 1104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_toobig) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, - 1112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sleep) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize - }, - 1120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(soft_heap_limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, - 1128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_find) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_register as *const _ as usize - }, - 1136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_register) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize - }, - 1144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_unregister) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize - }, - 1152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(xthreadsafe) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize - }, - 1160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_zeroblob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_code as *const _ as usize - }, - 1168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_code) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).test_control as *const _ as usize - }, - 1176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(test_control) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, - 1184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(randomness) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).context_db_handle as *const _ as usize - }, - 1192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(context_db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).extended_result_codes as *const _ - as usize - }, - 1200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(extended_result_codes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, - 1208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, - 1216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(next_stmt) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, - 1224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sql) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, - 1232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(status) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_finish as *const _ as usize - }, - 1240usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_finish) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_init as *const _ as usize - }, - 1248usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_init) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_pagecount as *const _ as usize - }, - 1256usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_pagecount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_remaining as *const _ as usize - }, - 1264usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_remaining) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_step as *const _ as usize - }, - 1272usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_step) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).compileoption_get as *const _ as usize - }, - 1280usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(compileoption_get) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).compileoption_used as *const _ as usize - }, - 1288usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(compileoption_used) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function_v2 as *const _ as usize - }, - 1296usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function_v2) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_config as *const _ as usize }, - 1304usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_config) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_mutex as *const _ as usize }, - 1312usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_mutex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_status as *const _ as usize }, - 1320usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_status) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).extended_errcode as *const _ as usize - }, - 1328usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(extended_errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).log as *const _ as usize }, - 1336usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(log) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).soft_heap_limit64 as *const _ as usize - }, - 1344usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(soft_heap_limit64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sourceid as *const _ as usize }, - 1352usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sourceid) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stmt_status as *const _ as usize - }, - 1360usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_status) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).strnicmp as *const _ as usize }, - 1368usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(strnicmp) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).unlock_notify as *const _ as usize - }, - 1376usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(unlock_notify) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_autocheckpoint as *const _ as usize - }, - 1384usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_autocheckpoint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_checkpoint as *const _ as usize - }, - 1392usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_checkpoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).wal_hook as *const _ as usize }, - 1400usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_hook) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).blob_reopen as *const _ as usize - }, - 1408usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_reopen) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtab_config as *const _ as usize - }, - 1416usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vtab_config) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtab_on_conflict as *const _ as usize - }, - 1424usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vtab_on_conflict) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).close_v2 as *const _ as usize }, - 1432usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(close_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_filename as *const _ as usize - }, - 1440usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_filename) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_readonly as *const _ as usize - }, - 1448usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_readonly) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_release_memory as *const _ as usize - }, - 1456usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_release_memory) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errstr as *const _ as usize }, - 1464usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errstr) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).stmt_busy as *const _ as usize }, - 1472usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_busy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stmt_readonly as *const _ as usize - }, - 1480usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_readonly) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).stricmp as *const _ as usize }, - 1488usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stricmp) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).uri_boolean as *const _ as usize - }, - 1496usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(uri_boolean) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).uri_int64 as *const _ as usize }, - 1504usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(uri_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).uri_parameter as *const _ as usize - }, - 1512usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(uri_parameter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xvsnprintf as *const _ as usize }, - 1520usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(xvsnprintf) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_checkpoint_v2 as *const _ as usize - }, - 1528usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_checkpoint_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).auto_extension as *const _ as usize - }, - 1536usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(auto_extension) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_blob64 as *const _ as usize - }, - 1544usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_blob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_text64 as *const _ as usize - }, - 1552usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).cancel_auto_extension as *const _ - as usize - }, - 1560usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(cancel_auto_extension) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).load_extension as *const _ as usize - }, - 1568usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(load_extension) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).malloc64 as *const _ as usize }, - 1576usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(malloc64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).msize as *const _ as usize }, - 1584usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(msize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).realloc64 as *const _ as usize }, - 1592usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(realloc64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).reset_auto_extension as *const _ - as usize - }, - 1600usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(reset_auto_extension) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_blob64 as *const _ as usize - }, - 1608usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_blob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text64 as *const _ as usize - }, - 1616usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).strglob as *const _ as usize }, - 1624usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(strglob) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_dup as *const _ as usize }, - 1632usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_dup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_free as *const _ as usize }, - 1640usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_free) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_zeroblob64 as *const _ as usize - }, - 1648usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_zeroblob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_zeroblob64 as *const _ as usize - }, - 1656usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_zeroblob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_subtype as *const _ as usize - }, - 1664usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_subtype) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_subtype as *const _ as usize - }, - 1672usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_subtype) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).status64 as *const _ as usize }, - 1680usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(status64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).strlike as *const _ as usize }, - 1688usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(strlike) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_cacheflush as *const _ as usize - }, - 1696usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_cacheflush) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).system_errno as *const _ as usize - }, - 1704usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(system_errno) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).trace_v2 as *const _ as usize }, - 1712usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(trace_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).expanded_sql as *const _ as usize - }, - 1720usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(expanded_sql) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_last_insert_rowid as *const _ - as usize - }, - 1728usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_last_insert_rowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare_v3 as *const _ as usize }, - 1736usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare_v3) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).prepare16_v3 as *const _ as usize - }, - 1744usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16_v3) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_pointer as *const _ as usize - }, - 1752usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_pointer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_pointer as *const _ as usize - }, - 1760usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_pointer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_pointer as *const _ as usize - }, - 1768usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_pointer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtab_nochange as *const _ as usize - }, - 1776usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vtab_nochange) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_nochange as *const _ as usize - }, - 1784usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_nochange) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtab_collation as *const _ as usize - }, - 1792usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vtab_collation) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).keyword_count as *const _ as usize - }, - 1800usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(keyword_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).keyword_name as *const _ as usize - }, - 1808usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(keyword_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).keyword_check as *const _ as usize - }, - 1816usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(keyword_check) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).str_new as *const _ as usize }, - 1824usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_new) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).str_finish as *const _ as usize }, - 1832usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_finish) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).str_appendf as *const _ as usize - }, - 1840usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_appendf) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).str_vappendf as *const _ as usize - }, - 1848usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_vappendf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).str_append as *const _ as usize }, - 1856usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_append) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).str_appendall as *const _ as usize - }, - 1864usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_appendall) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).str_appendchar as *const _ as usize - }, - 1872usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_appendchar) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).str_reset as *const _ as usize }, - 1880usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_reset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).str_errcode as *const _ as usize - }, - 1888usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).str_length as *const _ as usize }, - 1896usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_length) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).str_value as *const _ as usize }, - 1904usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_window_function as *const _ - as usize - }, - 1912usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_window_function) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).normalized_sql as *const _ as usize - }, - 1920usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(normalized_sql) - ) - ); -} -pub type sqlite3_loadext_entry = ::std::option::Option< - unsafe extern "C" fn( - db: *mut sqlite3, - pzErrMsg: *mut *mut ::std::os::raw::c_char, - pThunk: *const sqlite3_api_routines, - ) -> ::std::os::raw::c_int, ->; -pub type __builtin_va_list = [__va_list_tag; 1usize]; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct __va_list_tag { - pub gp_offset: ::std::os::raw::c_uint, - pub fp_offset: ::std::os::raw::c_uint, - pub overflow_arg_area: *mut ::std::os::raw::c_void, - pub reg_save_area: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout___va_list_tag() { - assert_eq!( - ::std::mem::size_of::<__va_list_tag>(), - 24usize, - concat!("Size of: ", stringify!(__va_list_tag)) - ); - assert_eq!( - ::std::mem::align_of::<__va_list_tag>(), - 8usize, - concat!("Alignment of ", stringify!(__va_list_tag)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(gp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(fp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(overflow_arg_area) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(reg_save_area) - ) - ); -} - -// bindings were built with loadable_extension_embedded: -// define sqlite3_api as an extern since this code will be embedded -// within a loadable extension that defines and exports this itself -extern "C" { - #[no_mangle] - pub static mut sqlite3_api: *mut sqlite3_api_routines; -} - -// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) - -pub unsafe fn sqlite3_aggregate_context( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_context.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_context", - " function" - )))(arg1, nBytes) -} - -pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_blob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_blob", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_double( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_double", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_null( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_null", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_parameter_index( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_index.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_index", - " function" - )))(arg1, zName) -} - -pub unsafe fn sqlite3_bind_parameter_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_text( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_text16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_bind_value( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_value", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_handler( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_handler", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_timeout( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_timeout.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_timeout", - " function" - )))(arg1, ms) -} - -pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_collation_needed( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_collation_needed16( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_column_blob( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_blob", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_column_database_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_database_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_decltype( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype", - " function" - )))(arg1, i) -} - -pub unsafe fn sqlite3_column_decltype16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_double", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int64( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int64", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_text( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_text16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_type( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_type", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_value( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_value", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_commit_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).commit_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "commit_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete16", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_create_collation( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_collation16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_function( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_function16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function16", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_module( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).data_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "data_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_declare_vtab( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).declare_vtab.expect(stringify!( - "sqlite3_api contains null pointer for ", - "declare_vtab", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).enable_shared_cache.expect(stringify!( - "sqlite3_api contains null pointer for ", - "enable_shared_cache", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errcode", - " function" - )))(db) -} - -pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_exec( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).exec.expect(stringify!( - "sqlite3_api contains null pointer for ", - "exec", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).expired.expect(stringify!( - "sqlite3_api contains null pointer for ", - "expired", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).finalize.expect(stringify!( - "sqlite3_api contains null pointer for ", - "finalize", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free_table", - " function" - )))(result) -} - -pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_autocommit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_autocommit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_get_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_auxdata", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_get_table( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_table", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).global_recover.expect(stringify!( - "sqlite3_api contains null pointer for ", - "global_recover", - " function" - )))() -} - -pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).interruptx.expect(stringify!( - "sqlite3_api contains null pointer for ", - "interruptx", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).last_insert_rowid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "last_insert_rowid", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion", - " function" - )))() -} - -pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion_number.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion_number", - " function" - )))() -} - -pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).malloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "malloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mprintf( - arg1: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mprintf", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_open( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_open16( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_prepare( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_profile( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).profile.expect(stringify!( - "sqlite3_api contains null pointer for ", - "profile", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_progress_handler( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).progress_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "progress_handler", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_realloc( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).realloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "realloc", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).reset.expect(stringify!( - "sqlite3_api contains null pointer for ", - "reset", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_result_blob( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_blob", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_double", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_error16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_null", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_text( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16be( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16be", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16le( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16le", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_value", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_rollback_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).rollback_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "rollback_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_authorizer( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_authorizer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_authorizer", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_auxdata", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_xsnprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).xsnprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "xsnprintf", - " function" - )))(arg1, arg2, arg3, vararg1) -} - -pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).step.expect(stringify!( - "sqlite3_api contains null pointer for ", - "step", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_table_column_metadata( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).table_column_metadata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "table_column_metadata", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) -} - -pub unsafe fn sqlite3_thread_cleanup() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).thread_cleanup.expect(stringify!( - "sqlite3_api contains null pointer for ", - "thread_cleanup", - " function" - )))() -} - -pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).total_changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "total_changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_trace( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).trace.expect(stringify!( - "sqlite3_api contains null pointer for ", - "trace", - " function" - )))(arg1, xTrace, arg2) -} - -pub unsafe fn sqlite3_transfer_bindings( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).transfer_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "transfer_bindings", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_update_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).update_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "update_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).user_data.expect(stringify!( - "sqlite3_api contains null pointer for ", - "user_data", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_blob", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_double", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_numeric_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_numeric_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16be", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16le", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vmprintf( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vmprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vmprintf", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_overload_function( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).overload_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "overload_function", - " function" - )))(arg1, zFuncName, nArg) -} - -pub unsafe fn sqlite3_prepare_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).clear_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "clear_bindings", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_module_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module_v2", - " function" - )))(arg1, arg2, arg3, arg4, xDestroy) -} - -pub unsafe fn sqlite3_bind_zeroblob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_zeroblob", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_open( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_open", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) -} - -pub unsafe fn sqlite3_blob_read( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_read.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_read", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_blob_write( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_write.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_write", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_create_collation_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_file_control( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).file_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "file_control", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_highwater.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_highwater", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_used.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_used", - " function" - )))() -} - -pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_alloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_alloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_enter.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_enter", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_leave.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_leave", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_try.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_try", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_open_v2( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open_v2", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).release_memory.expect(stringify!( - "sqlite3_api contains null pointer for ", - "release_memory", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_nomem.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_nomem", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_toobig.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_toobig", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sleep.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sleep", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).soft_heap_limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "soft_heap_limit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_find.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_find", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_register( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_register.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_register", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_unregister.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_unregister", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).xthreadsafe.expect(stringify!( - "sqlite3_api contains null pointer for ", - "xthreadsafe", - " function" - )))() -} - -pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_zeroblob", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_code.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_code", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_test_control( - arg1: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).test_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "test_control", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).randomness.expect(stringify!( - "sqlite3_api contains null pointer for ", - "randomness", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).context_db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "context_db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_extended_result_codes( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).extended_result_codes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "extended_result_codes", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_limit( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "limit", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).next_stmt.expect(stringify!( - "sqlite3_api contains null pointer for ", - "next_stmt", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sql.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sql", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_status( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "status", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_finish.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_finish", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_init( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut sqlite3, - arg4: *const ::std::os::raw::c_char, -) -> *mut sqlite3_backup { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_init.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_init", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_pagecount.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_pagecount", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_remaining.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_remaining", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_step( - arg1: *mut sqlite3_backup, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_step.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_step", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_compileoption_get( - arg1: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).compileoption_get.expect(stringify!( - "sqlite3_api contains null pointer for ", - "compileoption_get", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_compileoption_used( - arg1: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).compileoption_used.expect(stringify!( - "sqlite3_api contains null pointer for ", - "compileoption_used", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_function_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal, xDestroy) -} - -pub unsafe fn sqlite3_db_config( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, - vararg2: &mut i32, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_config.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_config", - " function" - )))(arg1, arg2, vararg1, vararg2) -} - -pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_mutex.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_mutex", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_db_status( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_status", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).extended_errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "extended_errcode", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_log( - arg1: ::std::os::raw::c_int, - arg2: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).log.expect(stringify!( - "sqlite3_api contains null pointer for ", - "log", - " function" - )))(arg1, arg2, vararg1) -} - -pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).soft_heap_limit64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "soft_heap_limit64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sourceid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sourceid", - " function" - )))() -} - -pub unsafe fn sqlite3_stmt_status( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_status", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_strnicmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).strnicmp.expect(stringify!( - "sqlite3_api contains null pointer for ", - "strnicmp", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_unlock_notify( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int), - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).unlock_notify.expect(stringify!( - "sqlite3_api contains null pointer for ", - "unlock_notify", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_wal_autocheckpoint( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_autocheckpoint", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_wal_checkpoint( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_checkpoint.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_checkpoint", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_wal_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_blob_reopen( - arg1: *mut sqlite3_blob, - arg2: sqlite3_int64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_reopen.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_reopen", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vtab_config( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vtab_config.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vtab_config", - " function" - )))(arg1, op, vararg1) -} - -pub unsafe fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vtab_on_conflict.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vtab_on_conflict", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "close_v2", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_db_filename( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_filename.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_filename", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_db_readonly( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_readonly.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_readonly", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_release_memory.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_release_memory", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errstr.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errstr", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_busy.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_busy", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_stmt_readonly(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_readonly.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_readonly", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_stricmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stricmp.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stricmp", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_uri_boolean( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).uri_boolean.expect(stringify!( - "sqlite3_api contains null pointer for ", - "uri_boolean", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_uri_int64( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_int64, -) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).uri_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "uri_int64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_uri_parameter( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).uri_parameter.expect(stringify!( - "sqlite3_api contains null pointer for ", - "uri_parameter", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_xvsnprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut __va_list_tag, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).xvsnprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "xvsnprintf", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_wal_checkpoint_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_checkpoint_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_checkpoint_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_auto_extension( - arg1: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).auto_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "auto_extension", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_blob64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_blob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_blob64", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_bind_text64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - arg6: ::std::os::raw::c_uchar, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text64", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_cancel_auto_extension( - arg1: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).cancel_auto_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "cancel_auto_extension", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_load_extension( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).load_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "load_extension", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_malloc64(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).malloc64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "malloc64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_msize(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).msize.expect(stringify!( - "sqlite3_api contains null pointer for ", - "msize", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_realloc64( - arg1: *mut ::std::os::raw::c_void, - arg2: sqlite3_uint64, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).realloc64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "realloc64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_reset_auto_extension() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).reset_auto_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "reset_auto_extension", - " function" - )))() -} - -pub unsafe fn sqlite3_result_blob64( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_blob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_blob64", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text64( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - arg5: ::std::os::raw::c_uchar, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text64", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_strglob( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).strglob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "strglob", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_value_dup(arg1: *const sqlite3_value) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_dup.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_dup", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_free(arg1: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_zeroblob64( - arg1: *mut sqlite3_context, - arg2: sqlite3_uint64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_zeroblob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_zeroblob64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_zeroblob64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_uint64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_zeroblob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_zeroblob64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_value_subtype(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_subtype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_subtype", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_subtype(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_subtype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_subtype", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_status64( - arg1: ::std::os::raw::c_int, - arg2: *mut sqlite3_int64, - arg3: *mut sqlite3_int64, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).status64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "status64", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_strlike( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_uint, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).strlike.expect(stringify!( - "sqlite3_api contains null pointer for ", - "strlike", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_db_cacheflush(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_cacheflush.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_cacheflush", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_system_errno(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).system_errno.expect(stringify!( - "sqlite3_api contains null pointer for ", - "system_errno", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_trace_v2( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_uint, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_uint, - arg2: *mut ::std::os::raw::c_void, - arg3: *mut ::std::os::raw::c_void, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).trace_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "trace_v2", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_expanded_sql(arg1: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).expanded_sql.expect(stringify!( - "sqlite3_api contains null pointer for ", - "expanded_sql", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_set_last_insert_rowid(arg1: *mut sqlite3, arg2: sqlite3_int64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_last_insert_rowid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_last_insert_rowid", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_prepare_v3( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_uint, - arg5: *mut *mut sqlite3_stmt, - arg6: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare_v3.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare_v3", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_prepare16_v3( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_uint, - arg5: *mut *mut sqlite3_stmt, - arg6: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16_v3.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16_v3", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_bind_pointer( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: *const ::std::os::raw::c_char, - arg5: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_pointer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_pointer", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_result_pointer( - arg1: *mut sqlite3_context, - arg2: *mut ::std::os::raw::c_void, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_pointer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_pointer", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_value_pointer( - arg1: *mut sqlite3_value, - arg2: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_pointer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_pointer", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vtab_nochange(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vtab_nochange.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vtab_nochange", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_nochange(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_nochange.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_nochange", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vtab_collation( - arg1: *mut sqlite3_index_info, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vtab_collation.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vtab_collation", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_keyword_count() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).keyword_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "keyword_count", - " function" - )))() -} - -pub unsafe fn sqlite3_keyword_name( - arg1: ::std::os::raw::c_int, - arg2: *mut *const ::std::os::raw::c_char, - arg3: *mut ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).keyword_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "keyword_name", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_keyword_check( - arg1: *const ::std::os::raw::c_char, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).keyword_check.expect(stringify!( - "sqlite3_api contains null pointer for ", - "keyword_check", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_str_new(arg1: *mut sqlite3) -> *mut sqlite3_str { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_new.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_new", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_str_finish(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_finish.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_finish", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_str_appendf( - arg1: *mut sqlite3_str, - zFormat: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_appendf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_appendf", - " function" - )))(arg1, zFormat, vararg1) -} - -pub unsafe fn sqlite3_str_vappendf( - arg1: *mut sqlite3_str, - zFormat: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_vappendf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_vappendf", - " function" - )))(arg1, zFormat, arg2) -} - -pub unsafe fn sqlite3_str_append( - arg1: *mut sqlite3_str, - zIn: *const ::std::os::raw::c_char, - N: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_append.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_append", - " function" - )))(arg1, zIn, N) -} - -pub unsafe fn sqlite3_str_appendall(arg1: *mut sqlite3_str, zIn: *const ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_appendall.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_appendall", - " function" - )))(arg1, zIn) -} - -pub unsafe fn sqlite3_str_appendchar( - arg1: *mut sqlite3_str, - N: ::std::os::raw::c_int, - C: ::std::os::raw::c_char, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_appendchar.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_appendchar", - " function" - )))(arg1, N, C) -} - -pub unsafe fn sqlite3_str_reset(arg1: *mut sqlite3_str) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_reset.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_reset", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_str_errcode(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_errcode", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_str_length(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_length.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_length", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_str_value(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_value", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_window_function( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xValue: ::std::option::Option, - xInv: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_window_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_window_function", - " function" - )))( - arg1, arg2, arg3, arg4, arg5, xStep, xFinal, xValue, xInv, xDestroy, - ) -} - -pub unsafe fn sqlite3_normalized_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).normalized_sql.expect(stringify!( - "sqlite3_api contains null pointer for ", - "normalized_sql", - " function" - )))(arg1) -} diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.26.0-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.26.0-ext.rs deleted file mode 100644 index 5aafee43e..000000000 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.26.0-ext.rs +++ /dev/null @@ -1,11138 +0,0 @@ -/* automatically generated by rust-bindgen */ - -pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.26.0\0"; -pub const SQLITE_VERSION_NUMBER: i32 = 3026000; -pub const SQLITE_SOURCE_ID: &'static [u8; 85usize] = - b"2018-12-01 12:34:55 bf8c1b2b7a5960c282e543b9c293686dccff272512d08865f4600fb58238b4f9\0"; -pub const SQLITE_OK: i32 = 0; -pub const SQLITE_ERROR: i32 = 1; -pub const SQLITE_INTERNAL: i32 = 2; -pub const SQLITE_PERM: i32 = 3; -pub const SQLITE_ABORT: i32 = 4; -pub const SQLITE_BUSY: i32 = 5; -pub const SQLITE_LOCKED: i32 = 6; -pub const SQLITE_NOMEM: i32 = 7; -pub const SQLITE_READONLY: i32 = 8; -pub const SQLITE_INTERRUPT: i32 = 9; -pub const SQLITE_IOERR: i32 = 10; -pub const SQLITE_CORRUPT: i32 = 11; -pub const SQLITE_NOTFOUND: i32 = 12; -pub const SQLITE_FULL: i32 = 13; -pub const SQLITE_CANTOPEN: i32 = 14; -pub const SQLITE_PROTOCOL: i32 = 15; -pub const SQLITE_EMPTY: i32 = 16; -pub const SQLITE_SCHEMA: i32 = 17; -pub const SQLITE_TOOBIG: i32 = 18; -pub const SQLITE_CONSTRAINT: i32 = 19; -pub const SQLITE_MISMATCH: i32 = 20; -pub const SQLITE_MISUSE: i32 = 21; -pub const SQLITE_NOLFS: i32 = 22; -pub const SQLITE_AUTH: i32 = 23; -pub const SQLITE_FORMAT: i32 = 24; -pub const SQLITE_RANGE: i32 = 25; -pub const SQLITE_NOTADB: i32 = 26; -pub const SQLITE_NOTICE: i32 = 27; -pub const SQLITE_WARNING: i32 = 28; -pub const SQLITE_ROW: i32 = 100; -pub const SQLITE_DONE: i32 = 101; -pub const SQLITE_ERROR_MISSING_COLLSEQ: i32 = 257; -pub const SQLITE_ERROR_RETRY: i32 = 513; -pub const SQLITE_ERROR_SNAPSHOT: i32 = 769; -pub const SQLITE_IOERR_READ: i32 = 266; -pub const SQLITE_IOERR_SHORT_READ: i32 = 522; -pub const SQLITE_IOERR_WRITE: i32 = 778; -pub const SQLITE_IOERR_FSYNC: i32 = 1034; -pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; -pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; -pub const SQLITE_IOERR_FSTAT: i32 = 1802; -pub const SQLITE_IOERR_UNLOCK: i32 = 2058; -pub const SQLITE_IOERR_RDLOCK: i32 = 2314; -pub const SQLITE_IOERR_DELETE: i32 = 2570; -pub const SQLITE_IOERR_BLOCKED: i32 = 2826; -pub const SQLITE_IOERR_NOMEM: i32 = 3082; -pub const SQLITE_IOERR_ACCESS: i32 = 3338; -pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; -pub const SQLITE_IOERR_LOCK: i32 = 3850; -pub const SQLITE_IOERR_CLOSE: i32 = 4106; -pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; -pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; -pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; -pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; -pub const SQLITE_IOERR_SHMMAP: i32 = 5386; -pub const SQLITE_IOERR_SEEK: i32 = 5642; -pub const SQLITE_IOERR_DELETE_NOENT: i32 = 5898; -pub const SQLITE_IOERR_MMAP: i32 = 6154; -pub const SQLITE_IOERR_GETTEMPPATH: i32 = 6410; -pub const SQLITE_IOERR_CONVPATH: i32 = 6666; -pub const SQLITE_IOERR_VNODE: i32 = 6922; -pub const SQLITE_IOERR_AUTH: i32 = 7178; -pub const SQLITE_IOERR_BEGIN_ATOMIC: i32 = 7434; -pub const SQLITE_IOERR_COMMIT_ATOMIC: i32 = 7690; -pub const SQLITE_IOERR_ROLLBACK_ATOMIC: i32 = 7946; -pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; -pub const SQLITE_LOCKED_VTAB: i32 = 518; -pub const SQLITE_BUSY_RECOVERY: i32 = 261; -pub const SQLITE_BUSY_SNAPSHOT: i32 = 517; -pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; -pub const SQLITE_CANTOPEN_ISDIR: i32 = 526; -pub const SQLITE_CANTOPEN_FULLPATH: i32 = 782; -pub const SQLITE_CANTOPEN_CONVPATH: i32 = 1038; -pub const SQLITE_CANTOPEN_DIRTYWAL: i32 = 1294; -pub const SQLITE_CORRUPT_VTAB: i32 = 267; -pub const SQLITE_CORRUPT_SEQUENCE: i32 = 523; -pub const SQLITE_READONLY_RECOVERY: i32 = 264; -pub const SQLITE_READONLY_CANTLOCK: i32 = 520; -pub const SQLITE_READONLY_ROLLBACK: i32 = 776; -pub const SQLITE_READONLY_DBMOVED: i32 = 1032; -pub const SQLITE_READONLY_CANTINIT: i32 = 1288; -pub const SQLITE_READONLY_DIRECTORY: i32 = 1544; -pub const SQLITE_ABORT_ROLLBACK: i32 = 516; -pub const SQLITE_CONSTRAINT_CHECK: i32 = 275; -pub const SQLITE_CONSTRAINT_COMMITHOOK: i32 = 531; -pub const SQLITE_CONSTRAINT_FOREIGNKEY: i32 = 787; -pub const SQLITE_CONSTRAINT_FUNCTION: i32 = 1043; -pub const SQLITE_CONSTRAINT_NOTNULL: i32 = 1299; -pub const SQLITE_CONSTRAINT_PRIMARYKEY: i32 = 1555; -pub const SQLITE_CONSTRAINT_TRIGGER: i32 = 1811; -pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067; -pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323; -pub const SQLITE_CONSTRAINT_ROWID: i32 = 2579; -pub const SQLITE_NOTICE_RECOVER_WAL: i32 = 283; -pub const SQLITE_NOTICE_RECOVER_ROLLBACK: i32 = 539; -pub const SQLITE_WARNING_AUTOINDEX: i32 = 284; -pub const SQLITE_AUTH_USER: i32 = 279; -pub const SQLITE_OK_LOAD_PERMANENTLY: i32 = 256; -pub const SQLITE_OPEN_READONLY: i32 = 1; -pub const SQLITE_OPEN_READWRITE: i32 = 2; -pub const SQLITE_OPEN_CREATE: i32 = 4; -pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; -pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; -pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; -pub const SQLITE_OPEN_URI: i32 = 64; -pub const SQLITE_OPEN_MEMORY: i32 = 128; -pub const SQLITE_OPEN_MAIN_DB: i32 = 256; -pub const SQLITE_OPEN_TEMP_DB: i32 = 512; -pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; -pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; -pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; -pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; -pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; -pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; -pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; -pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; -pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; -pub const SQLITE_OPEN_WAL: i32 = 524288; -pub const SQLITE_IOCAP_ATOMIC: i32 = 1; -pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; -pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; -pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; -pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; -pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; -pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; -pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; -pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; -pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; -pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; -pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; -pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE: i32 = 4096; -pub const SQLITE_IOCAP_IMMUTABLE: i32 = 8192; -pub const SQLITE_IOCAP_BATCH_ATOMIC: i32 = 16384; -pub const SQLITE_LOCK_NONE: i32 = 0; -pub const SQLITE_LOCK_SHARED: i32 = 1; -pub const SQLITE_LOCK_RESERVED: i32 = 2; -pub const SQLITE_LOCK_PENDING: i32 = 3; -pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; -pub const SQLITE_SYNC_NORMAL: i32 = 2; -pub const SQLITE_SYNC_FULL: i32 = 3; -pub const SQLITE_SYNC_DATAONLY: i32 = 16; -pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; -pub const SQLITE_FCNTL_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_FCNTL_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_FCNTL_LAST_ERRNO: i32 = 4; -pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; -pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; -pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; -pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; -pub const SQLITE_FCNTL_WIN32_AV_RETRY: i32 = 9; -pub const SQLITE_FCNTL_PERSIST_WAL: i32 = 10; -pub const SQLITE_FCNTL_OVERWRITE: i32 = 11; -pub const SQLITE_FCNTL_VFSNAME: i32 = 12; -pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE: i32 = 13; -pub const SQLITE_FCNTL_PRAGMA: i32 = 14; -pub const SQLITE_FCNTL_BUSYHANDLER: i32 = 15; -pub const SQLITE_FCNTL_TEMPFILENAME: i32 = 16; -pub const SQLITE_FCNTL_MMAP_SIZE: i32 = 18; -pub const SQLITE_FCNTL_TRACE: i32 = 19; -pub const SQLITE_FCNTL_HAS_MOVED: i32 = 20; -pub const SQLITE_FCNTL_SYNC: i32 = 21; -pub const SQLITE_FCNTL_COMMIT_PHASETWO: i32 = 22; -pub const SQLITE_FCNTL_WIN32_SET_HANDLE: i32 = 23; -pub const SQLITE_FCNTL_WAL_BLOCK: i32 = 24; -pub const SQLITE_FCNTL_ZIPVFS: i32 = 25; -pub const SQLITE_FCNTL_RBU: i32 = 26; -pub const SQLITE_FCNTL_VFS_POINTER: i32 = 27; -pub const SQLITE_FCNTL_JOURNAL_POINTER: i32 = 28; -pub const SQLITE_FCNTL_WIN32_GET_HANDLE: i32 = 29; -pub const SQLITE_FCNTL_PDB: i32 = 30; -pub const SQLITE_FCNTL_BEGIN_ATOMIC_WRITE: i32 = 31; -pub const SQLITE_FCNTL_COMMIT_ATOMIC_WRITE: i32 = 32; -pub const SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE: i32 = 33; -pub const SQLITE_FCNTL_LOCK_TIMEOUT: i32 = 34; -pub const SQLITE_FCNTL_DATA_VERSION: i32 = 35; -pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_LAST_ERRNO: i32 = 4; -pub const SQLITE_ACCESS_EXISTS: i32 = 0; -pub const SQLITE_ACCESS_READWRITE: i32 = 1; -pub const SQLITE_ACCESS_READ: i32 = 2; -pub const SQLITE_SHM_UNLOCK: i32 = 1; -pub const SQLITE_SHM_LOCK: i32 = 2; -pub const SQLITE_SHM_SHARED: i32 = 4; -pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; -pub const SQLITE_SHM_NLOCK: i32 = 8; -pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; -pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; -pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; -pub const SQLITE_CONFIG_MALLOC: i32 = 4; -pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; -pub const SQLITE_CONFIG_SCRATCH: i32 = 6; -pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; -pub const SQLITE_CONFIG_HEAP: i32 = 8; -pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; -pub const SQLITE_CONFIG_MUTEX: i32 = 10; -pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; -pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; -pub const SQLITE_CONFIG_PCACHE: i32 = 14; -pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; -pub const SQLITE_CONFIG_LOG: i32 = 16; -pub const SQLITE_CONFIG_URI: i32 = 17; -pub const SQLITE_CONFIG_PCACHE2: i32 = 18; -pub const SQLITE_CONFIG_GETPCACHE2: i32 = 19; -pub const SQLITE_CONFIG_COVERING_INDEX_SCAN: i32 = 20; -pub const SQLITE_CONFIG_SQLLOG: i32 = 21; -pub const SQLITE_CONFIG_MMAP_SIZE: i32 = 22; -pub const SQLITE_CONFIG_WIN32_HEAPSIZE: i32 = 23; -pub const SQLITE_CONFIG_PCACHE_HDRSZ: i32 = 24; -pub const SQLITE_CONFIG_PMASZ: i32 = 25; -pub const SQLITE_CONFIG_STMTJRNL_SPILL: i32 = 26; -pub const SQLITE_CONFIG_SMALL_MALLOC: i32 = 27; -pub const SQLITE_CONFIG_SORTERREF_SIZE: i32 = 28; -pub const SQLITE_DBCONFIG_MAINDBNAME: i32 = 1000; -pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; -pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; -pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; -pub const SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: i32 = 1004; -pub const SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: i32 = 1005; -pub const SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE: i32 = 1006; -pub const SQLITE_DBCONFIG_ENABLE_QPSG: i32 = 1007; -pub const SQLITE_DBCONFIG_TRIGGER_EQP: i32 = 1008; -pub const SQLITE_DBCONFIG_RESET_DATABASE: i32 = 1009; -pub const SQLITE_DBCONFIG_DEFENSIVE: i32 = 1010; -pub const SQLITE_DBCONFIG_MAX: i32 = 1010; -pub const SQLITE_DENY: i32 = 1; -pub const SQLITE_IGNORE: i32 = 2; -pub const SQLITE_CREATE_INDEX: i32 = 1; -pub const SQLITE_CREATE_TABLE: i32 = 2; -pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; -pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; -pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; -pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; -pub const SQLITE_CREATE_TRIGGER: i32 = 7; -pub const SQLITE_CREATE_VIEW: i32 = 8; -pub const SQLITE_DELETE: i32 = 9; -pub const SQLITE_DROP_INDEX: i32 = 10; -pub const SQLITE_DROP_TABLE: i32 = 11; -pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; -pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; -pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; -pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; -pub const SQLITE_DROP_TRIGGER: i32 = 16; -pub const SQLITE_DROP_VIEW: i32 = 17; -pub const SQLITE_INSERT: i32 = 18; -pub const SQLITE_PRAGMA: i32 = 19; -pub const SQLITE_READ: i32 = 20; -pub const SQLITE_SELECT: i32 = 21; -pub const SQLITE_TRANSACTION: i32 = 22; -pub const SQLITE_UPDATE: i32 = 23; -pub const SQLITE_ATTACH: i32 = 24; -pub const SQLITE_DETACH: i32 = 25; -pub const SQLITE_ALTER_TABLE: i32 = 26; -pub const SQLITE_REINDEX: i32 = 27; -pub const SQLITE_ANALYZE: i32 = 28; -pub const SQLITE_CREATE_VTABLE: i32 = 29; -pub const SQLITE_DROP_VTABLE: i32 = 30; -pub const SQLITE_FUNCTION: i32 = 31; -pub const SQLITE_SAVEPOINT: i32 = 32; -pub const SQLITE_COPY: i32 = 0; -pub const SQLITE_RECURSIVE: i32 = 33; -pub const SQLITE_TRACE_STMT: i32 = 1; -pub const SQLITE_TRACE_PROFILE: i32 = 2; -pub const SQLITE_TRACE_ROW: i32 = 4; -pub const SQLITE_TRACE_CLOSE: i32 = 8; -pub const SQLITE_LIMIT_LENGTH: i32 = 0; -pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; -pub const SQLITE_LIMIT_COLUMN: i32 = 2; -pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; -pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; -pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; -pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; -pub const SQLITE_LIMIT_ATTACHED: i32 = 7; -pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; -pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; -pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; -pub const SQLITE_LIMIT_WORKER_THREADS: i32 = 11; -pub const SQLITE_PREPARE_PERSISTENT: i32 = 1; -pub const SQLITE_PREPARE_NORMALIZE: i32 = 2; -pub const SQLITE_INTEGER: i32 = 1; -pub const SQLITE_FLOAT: i32 = 2; -pub const SQLITE_BLOB: i32 = 4; -pub const SQLITE_NULL: i32 = 5; -pub const SQLITE_TEXT: i32 = 3; -pub const SQLITE3_TEXT: i32 = 3; -pub const SQLITE_UTF8: i32 = 1; -pub const SQLITE_UTF16LE: i32 = 2; -pub const SQLITE_UTF16BE: i32 = 3; -pub const SQLITE_UTF16: i32 = 4; -pub const SQLITE_ANY: i32 = 5; -pub const SQLITE_UTF16_ALIGNED: i32 = 8; -pub const SQLITE_DETERMINISTIC: i32 = 2048; -pub const SQLITE_WIN32_DATA_DIRECTORY_TYPE: i32 = 1; -pub const SQLITE_WIN32_TEMP_DIRECTORY_TYPE: i32 = 2; -pub const SQLITE_INDEX_SCAN_UNIQUE: i32 = 1; -pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; -pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; -pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; -pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; -pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; -pub const SQLITE_INDEX_CONSTRAINT_LIKE: i32 = 65; -pub const SQLITE_INDEX_CONSTRAINT_GLOB: i32 = 66; -pub const SQLITE_INDEX_CONSTRAINT_REGEXP: i32 = 67; -pub const SQLITE_INDEX_CONSTRAINT_NE: i32 = 68; -pub const SQLITE_INDEX_CONSTRAINT_ISNOT: i32 = 69; -pub const SQLITE_INDEX_CONSTRAINT_ISNOTNULL: i32 = 70; -pub const SQLITE_INDEX_CONSTRAINT_ISNULL: i32 = 71; -pub const SQLITE_INDEX_CONSTRAINT_IS: i32 = 72; -pub const SQLITE_INDEX_CONSTRAINT_FUNCTION: i32 = 150; -pub const SQLITE_MUTEX_FAST: i32 = 0; -pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; -pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; -pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; -pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; -pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; -pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; -pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; -pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; -pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; -pub const SQLITE_MUTEX_STATIC_APP1: i32 = 8; -pub const SQLITE_MUTEX_STATIC_APP2: i32 = 9; -pub const SQLITE_MUTEX_STATIC_APP3: i32 = 10; -pub const SQLITE_MUTEX_STATIC_VFS1: i32 = 11; -pub const SQLITE_MUTEX_STATIC_VFS2: i32 = 12; -pub const SQLITE_MUTEX_STATIC_VFS3: i32 = 13; -pub const SQLITE_TESTCTRL_FIRST: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; -pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; -pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; -pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; -pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; -pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; -pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; -pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; -pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; -pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; -pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; -pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 17; -pub const SQLITE_TESTCTRL_INTERNAL_FUNCTIONS: i32 = 17; -pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 18; -pub const SQLITE_TESTCTRL_EXPLAIN_STMT: i32 = 19; -pub const SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD: i32 = 19; -pub const SQLITE_TESTCTRL_NEVER_CORRUPT: i32 = 20; -pub const SQLITE_TESTCTRL_VDBE_COVERAGE: i32 = 21; -pub const SQLITE_TESTCTRL_BYTEORDER: i32 = 22; -pub const SQLITE_TESTCTRL_ISINIT: i32 = 23; -pub const SQLITE_TESTCTRL_SORTER_MMAP: i32 = 24; -pub const SQLITE_TESTCTRL_IMPOSTER: i32 = 25; -pub const SQLITE_TESTCTRL_PARSER_COVERAGE: i32 = 26; -pub const SQLITE_TESTCTRL_LAST: i32 = 26; -pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; -pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; -pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; -pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; -pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; -pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; -pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; -pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; -pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; -pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; -pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; -pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; -pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; -pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; -pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; -pub const SQLITE_DBSTATUS_CACHE_HIT: i32 = 7; -pub const SQLITE_DBSTATUS_CACHE_MISS: i32 = 8; -pub const SQLITE_DBSTATUS_CACHE_WRITE: i32 = 9; -pub const SQLITE_DBSTATUS_DEFERRED_FKS: i32 = 10; -pub const SQLITE_DBSTATUS_CACHE_USED_SHARED: i32 = 11; -pub const SQLITE_DBSTATUS_CACHE_SPILL: i32 = 12; -pub const SQLITE_DBSTATUS_MAX: i32 = 12; -pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; -pub const SQLITE_STMTSTATUS_SORT: i32 = 2; -pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; -pub const SQLITE_STMTSTATUS_VM_STEP: i32 = 4; -pub const SQLITE_STMTSTATUS_REPREPARE: i32 = 5; -pub const SQLITE_STMTSTATUS_RUN: i32 = 6; -pub const SQLITE_STMTSTATUS_MEMUSED: i32 = 99; -pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; -pub const SQLITE_CHECKPOINT_FULL: i32 = 1; -pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; -pub const SQLITE_CHECKPOINT_TRUNCATE: i32 = 3; -pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; -pub const SQLITE_ROLLBACK: i32 = 1; -pub const SQLITE_FAIL: i32 = 3; -pub const SQLITE_REPLACE: i32 = 5; -pub const SQLITE_SCANSTAT_NLOOP: i32 = 0; -pub const SQLITE_SCANSTAT_NVISIT: i32 = 1; -pub const SQLITE_SCANSTAT_EST: i32 = 2; -pub const SQLITE_SCANSTAT_NAME: i32 = 3; -pub const SQLITE_SCANSTAT_EXPLAIN: i32 = 4; -pub const SQLITE_SCANSTAT_SELECTID: i32 = 5; -pub const SQLITE_SERIALIZE_NOCOPY: i32 = 1; -pub const SQLITE_DESERIALIZE_FREEONCLOSE: i32 = 1; -pub const SQLITE_DESERIALIZE_RESIZEABLE: i32 = 2; -pub const SQLITE_DESERIALIZE_READONLY: i32 = 4; -pub const NOT_WITHIN: i32 = 0; -pub const PARTLY_WITHIN: i32 = 1; -pub const FULLY_WITHIN: i32 = 2; -pub const FTS5_TOKENIZE_QUERY: i32 = 1; -pub const FTS5_TOKENIZE_PREFIX: i32 = 2; -pub const FTS5_TOKENIZE_DOCUMENT: i32 = 4; -pub const FTS5_TOKENIZE_AUX: i32 = 8; -pub const FTS5_TOKEN_COLOCATED: i32 = 1; -pub type va_list = __builtin_va_list; -pub type __gnuc_va_list = __builtin_va_list; -extern "C" { - #[link_name = "\u{1}sqlite3_version"] - pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3 { - _unused: [u8; 0], -} -pub type sqlite_int64 = ::std::os::raw::c_longlong; -pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; -pub type sqlite3_int64 = sqlite_int64; -pub type sqlite3_uint64 = sqlite_uint64; -pub type sqlite3_callback = ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_file { - pub pMethods: *const sqlite3_io_methods, -} -#[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_file)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_file)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_file), - "::", - stringify!(pMethods) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_io_methods { - pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xRead: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *mut ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xWrite: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *const ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pSize: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xUnlock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCheckReservedLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileControl: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - op: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xSectorSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xDeviceCharacteristics: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xShmMap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iPg: ::std::os::raw::c_int, - pgsz: ::std::os::raw::c_int, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xShmLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - offset: ::std::os::raw::c_int, - n: ::std::os::raw::c_int, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xShmBarrier: ::std::option::Option, - pub xShmUnmap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - deleteFlag: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iOfst: sqlite3_int64, - iAmt: ::std::os::raw::c_int, - pp: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xUnfetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iOfst: sqlite3_int64, - p: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_io_methods() { - assert_eq!( - ::std::mem::size_of::(), - 152usize, - concat!("Size of: ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xRead) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xWrite) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnlock) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xCheckReservedLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileControl) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSectorSize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ - as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xDeviceCharacteristics) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmMap) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmBarrier) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmUnmap) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnfetch as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnfetch) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex { - _unused: [u8; 0], -} -pub type sqlite3_syscall_ptr = ::std::option::Option; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vfs { - pub iVersion: ::std::os::raw::c_int, - pub szOsFile: ::std::os::raw::c_int, - pub mxPathname: ::std::os::raw::c_int, - pub pNext: *mut sqlite3_vfs, - pub zName: *const ::std::os::raw::c_char, - pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - pOutFlags: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - syncDir: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xAccess: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - flags: ::std::os::raw::c_int, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFullPathname: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - nOut: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xDlOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zFilename: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void, - >, - pub xDlError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zErrMsg: *mut ::std::os::raw::c_char, - ), - >, - pub xDlSym: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ) -> ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ), - >, - >, - pub xDlClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), - >, - pub xRandomness: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSleep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - microseconds: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTime: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, - >, - pub xGetLastError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTimeInt64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xSetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: sqlite3_syscall_ptr, - ) -> ::std::os::raw::c_int, - >, - pub xGetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> sqlite3_syscall_ptr, - >, - pub xNextSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!( - ::std::mem::size_of::(), - 168usize, - concat!("Size of: ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(szOsFile) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(mxPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(zName) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pAppData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xAccess) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xFullPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlSym) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xRandomness) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSleep) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTime) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetLastError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTimeInt64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xNextSystemCall) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xRoundup: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub pAppData: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!( - ::std::mem::size_of::(), - 64usize, - concat!("Size of: ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xMalloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xFree) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRealloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRoundup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(pAppData) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_value { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_context { - _unused: [u8; 0], -} -pub type sqlite3_destructor_type = - ::std::option::Option; -extern "C" { - #[link_name = "\u{1}sqlite3_temp_directory"] - pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; -} -extern "C" { - #[link_name = "\u{1}sqlite3_data_directory"] - pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xConnect: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xBestIndex: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: *mut sqlite3_index_info, - ) -> ::std::os::raw::c_int, - >, - pub xDisconnect: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xDestroy: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - ppCursor: *mut *mut sqlite3_vtab_cursor, - ) -> ::std::os::raw::c_int, - >, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xFilter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - idxNum: ::std::os::raw::c_int, - idxStr: *const ::std::os::raw::c_char, - argc: ::std::os::raw::c_int, - argv: *mut *mut sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub xNext: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xEof: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - arg2: *mut sqlite3_context, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - pRowid: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xUpdate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - arg4: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xBegin: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xCommit: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xRollback: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xFindFunction: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - nArg: ::std::os::raw::c_int, - zName: *const ::std::os::raw::c_char, - pxFunc: *mut ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - ppArg: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xRename: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - zNew: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSavepoint: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRelease: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRollbackTo: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xShadowName: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!( - ::std::mem::size_of::(), - 192usize, - concat!("Size of: ", stringify!(sqlite3_module)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_module)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xConnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBestIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDisconnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFilter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xEof) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xColumn) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xUpdate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBegin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCommit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollback) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFindFunction) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRename) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSavepoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRelease) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollbackTo) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShadowName as *const _ as usize }, - 184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xShadowName) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info { - pub nConstraint: ::std::os::raw::c_int, - pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, - pub nOrderBy: ::std::os::raw::c_int, - pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, - pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, - pub idxNum: ::std::os::raw::c_int, - pub idxStr: *mut ::std::os::raw::c_char, - pub needToFreeIdxStr: ::std::os::raw::c_int, - pub orderByConsumed: ::std::os::raw::c_int, - pub estimatedCost: f64, - pub estimatedRows: sqlite3_int64, - pub idxFlags: ::std::os::raw::c_int, - pub colUsed: sqlite3_uint64, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint { - pub iColumn: ::std::os::raw::c_int, - pub op: ::std::os::raw::c_uchar, - pub usable: ::std::os::raw::c_uchar, - pub iTermOffset: ::std::os::raw::c_int, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).op as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(op) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).usable - as *const _ as usize - }, - 5usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(usable) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iTermOffset - as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iTermOffset) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_orderby { - pub iColumn: ::std::os::raw::c_int, - pub desc: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).desc as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(desc) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint_usage { - pub argvIndex: ::std::os::raw::c_int, - pub omit: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).argvIndex - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(argvIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).omit - as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(omit) - ) - ); -} -#[test] -fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!( - ::std::mem::size_of::(), - 96usize, - concat!("Size of: ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nOrderBy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aOrderBy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraintUsage) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxNum) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(needToFreeIdxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(orderByConsumed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedCost as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedCost) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedRows as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedRows) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxFlags as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxFlags) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).colUsed as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(colUsed) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(pModule) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(nRef) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(zErrMsg) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab_cursor { - pub pVtab: *mut sqlite3_vtab, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab_cursor), - "::", - stringify!(pVtab) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexNotheld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexInit as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnd) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexAlloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexFree as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexFree) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexTry) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexLeave) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexHeld) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexNotheld) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_str { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_page { - pub pBuf: *mut ::std::os::raw::c_void, - pub pExtra: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_page() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(sqlite3_pcache_page)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_page)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_page), - "::", - stringify!(pBuf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_page), - "::", - stringify!(pExtra) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods2 { - pub iVersion: ::std::os::raw::c_int, - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - szExtra: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache_page, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut sqlite3_pcache_page, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut sqlite3_pcache_page, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, - pub xShrink: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods2() { - assert_eq!( - ::std::mem::size_of::(), - 104usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iVersion as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDestroy as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xShrink) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods { - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!( - ::std::mem::size_of::(), - 88usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xDestroy) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_backup { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct sqlite3_snapshot { - pub hidden: [::std::os::raw::c_uchar; 48usize], -} -#[test] -fn bindgen_test_layout_sqlite3_snapshot() { - assert_eq!( - ::std::mem::size_of::(), - 48usize, - concat!("Size of: ", stringify!(sqlite3_snapshot)) - ); - assert_eq!( - ::std::mem::align_of::(), - 1usize, - concat!("Alignment of ", stringify!(sqlite3_snapshot)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).hidden as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_snapshot), - "::", - stringify!(hidden) - ) - ); -} -pub type sqlite3_rtree_dbl = f64; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_rtree_geometry { - pub pContext: *mut ::std::os::raw::c_void, - pub nParam: ::std::os::raw::c_int, - pub aParam: *mut sqlite3_rtree_dbl, - pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_rtree_geometry() { - assert_eq!( - ::std::mem::size_of::(), - 40usize, - concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pContext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(nParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(aParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pUser) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(xDelUser) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_rtree_query_info { - pub pContext: *mut ::std::os::raw::c_void, - pub nParam: ::std::os::raw::c_int, - pub aParam: *mut sqlite3_rtree_dbl, - pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, - pub aCoord: *mut sqlite3_rtree_dbl, - pub anQueue: *mut ::std::os::raw::c_uint, - pub nCoord: ::std::os::raw::c_int, - pub iLevel: ::std::os::raw::c_int, - pub mxLevel: ::std::os::raw::c_int, - pub iRowid: sqlite3_int64, - pub rParentScore: sqlite3_rtree_dbl, - pub eParentWithin: ::std::os::raw::c_int, - pub eWithin: ::std::os::raw::c_int, - pub rScore: sqlite3_rtree_dbl, - pub apSqlParam: *mut *mut sqlite3_value, -} -#[test] -fn bindgen_test_layout_sqlite3_rtree_query_info() { - assert_eq!( - ::std::mem::size_of::(), - 112usize, - concat!("Size of: ", stringify!(sqlite3_rtree_query_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_rtree_query_info)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).pContext as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(pContext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(nParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(aParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(pUser) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDelUser as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(xDelUser) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aCoord as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(aCoord) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).anQueue as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(anQueue) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nCoord as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(nCoord) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iLevel as *const _ as usize }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(iLevel) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mxLevel as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(mxLevel) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iRowid as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(iRowid) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rParentScore as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(rParentScore) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).eParentWithin as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(eParentWithin) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).eWithin as *const _ as usize - }, - 92usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(eWithin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).rScore as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(rScore) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).apSqlParam as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(apSqlParam) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5Context { - _unused: [u8; 0], -} -pub type fts5_extension_function = ::std::option::Option< - unsafe extern "C" fn( - pApi: *const Fts5ExtensionApi, - pFts: *mut Fts5Context, - pCtx: *mut sqlite3_context, - nVal: ::std::os::raw::c_int, - apVal: *mut *mut sqlite3_value, - ), ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5PhraseIter { - pub a: *const ::std::os::raw::c_uchar, - pub b: *const ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_Fts5PhraseIter() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(Fts5PhraseIter)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Fts5PhraseIter)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).a as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Fts5PhraseIter), - "::", - stringify!(a) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).b as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Fts5PhraseIter), - "::", - stringify!(b) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5ExtensionApi { - pub iVersion: ::std::os::raw::c_int, - pub xUserData: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> *mut ::std::os::raw::c_void, - >, - pub xColumnCount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, - >, - pub xRowCount: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pnRow: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xColumnTotalSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pnToken: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTokenize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pText: *const ::std::os::raw::c_char, - nText: ::std::os::raw::c_int, - pCtx: *mut ::std::os::raw::c_void, - xToken: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, - arg6: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseCount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, - >, - pub xPhraseSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xInstCount: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pnInst: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xInst: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iIdx: ::std::os::raw::c_int, - piPhrase: *mut ::std::os::raw::c_int, - piCol: *mut ::std::os::raw::c_int, - piOff: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: - ::std::option::Option sqlite3_int64>, - pub xColumnText: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pz: *mut *const ::std::os::raw::c_char, - pn: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xColumnSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pnToken: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xQueryPhrase: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - pUserData: *mut ::std::os::raw::c_void, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const Fts5ExtensionApi, - arg2: *mut Fts5Context, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub xSetAuxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pAux: *mut ::std::os::raw::c_void, - xDelete: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub xGetAuxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - bClear: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xPhraseFirst: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - arg2: *mut Fts5PhraseIter, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseNext: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - arg2: *mut Fts5PhraseIter, - piCol: *mut ::std::os::raw::c_int, - piOff: *mut ::std::os::raw::c_int, - ), - >, - pub xPhraseFirstColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - arg2: *mut Fts5PhraseIter, - arg3: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseNextColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - arg2: *mut Fts5PhraseIter, - piCol: *mut ::std::os::raw::c_int, - ), - >, -} -#[test] -fn bindgen_test_layout_Fts5ExtensionApi() { - assert_eq!( - ::std::mem::size_of::(), - 160usize, - concat!("Size of: ", stringify!(Fts5ExtensionApi)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Fts5ExtensionApi)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUserData as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xUserData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnCount as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowCount as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xRowCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xColumnTotalSize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnTotalSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xTokenize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseCount as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseSize as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInstCount as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xInstCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInst as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xInst) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnText as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnText) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnSize as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xQueryPhrase as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xQueryPhrase) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSetAuxdata as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xSetAuxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetAuxdata as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xGetAuxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseFirst as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseFirst) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseNext as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseNext) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPhraseFirstColumn as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseFirstColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPhraseNextColumn as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseNextColumn) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5Tokenizer { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct fts5_tokenizer { - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - azArg: *mut *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ppOut: *mut *mut Fts5Tokenizer, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option, - pub xTokenize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Tokenizer, - pCtx: *mut ::std::os::raw::c_void, - flags: ::std::os::raw::c_int, - pText: *const ::std::os::raw::c_char, - nText: ::std::os::raw::c_int, - xToken: ::std::option::Option< - unsafe extern "C" fn( - pCtx: *mut ::std::os::raw::c_void, - tflags: ::std::os::raw::c_int, - pToken: *const ::std::os::raw::c_char, - nToken: ::std::os::raw::c_int, - iStart: ::std::os::raw::c_int, - iEnd: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_fts5_tokenizer() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(fts5_tokenizer)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(fts5_tokenizer)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xTokenize) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct fts5_api { - pub iVersion: ::std::os::raw::c_int, - pub xCreateTokenizer: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - pContext: *mut ::std::os::raw::c_void, - pTokenizer: *mut fts5_tokenizer, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub xFindTokenizer: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - ppContext: *mut *mut ::std::os::raw::c_void, - pTokenizer: *mut fts5_tokenizer, - ) -> ::std::os::raw::c_int, - >, - pub xCreateFunction: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - pContext: *mut ::std::os::raw::c_void, - xFunction: fts5_extension_function, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_fts5_api() { - assert_eq!( - ::std::mem::size_of::(), - 32usize, - concat!("Size of: ", stringify!(fts5_api)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(fts5_api)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreateTokenizer as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xCreateTokenizer) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindTokenizer as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xFindTokenizer) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreateFunction as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xCreateFunction) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_api_routines { - pub aggregate_context: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub aggregate_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, - >, - pub bind_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_double: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, - ) -> ::std::os::raw::c_int, - >, - pub bind_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_int64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, - ) -> ::std::os::raw::c_int, - >, - pub bind_null: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub bind_parameter_index: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub bind_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub busy_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub busy_timeout: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub changes: - ::std::option::Option ::std::os::raw::c_int>, - pub close: - ::std::option::Option ::std::os::raw::c_int>, - pub collation_needed: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub collation_needed16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub column_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_bytes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_bytes16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub column_database_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_database_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_decltype: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_decltype16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_double: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, - >, - pub column_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_int64: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, - >, - pub column_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_origin_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_origin_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_table_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_table_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_uchar, - >, - pub column_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_type: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *mut sqlite3_value, - >, - pub commit_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub complete: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, - pub complete16: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub create_collation: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_collation16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_function16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_module: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub data_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub db_handle: - ::std::option::Option *mut sqlite3>, - pub declare_vtab: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub enable_shared_cache: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub errcode: - ::std::option::Option ::std::os::raw::c_int>, - pub errmsg: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, - >, - pub errmsg16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, - >, - pub exec: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub expired: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub finalize: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub free: ::std::option::Option, - pub free_table: - ::std::option::Option, - pub get_autocommit: - ::std::option::Option ::std::os::raw::c_int>, - pub get_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub get_table: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub global_recover: ::std::option::Option ::std::os::raw::c_int>, - pub interruptx: ::std::option::Option, - pub last_insert_rowid: - ::std::option::Option sqlite_int64>, - pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, - pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, - pub malloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub mprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub open16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub prepare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub profile: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub progress_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, - ), - >, - pub realloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub reset: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub result_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_double: - ::std::option::Option, - pub result_error: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_error16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_int64: - ::std::option::Option, - pub result_null: ::std::option::Option, - pub result_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16be: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16le: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_value: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), - >, - pub rollback_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub set_authorizer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub set_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, - ), - >, - pub xsnprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub step: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub table_column_metadata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub thread_cleanup: ::std::option::Option, - pub total_changes: - ::std::option::Option ::std::os::raw::c_int>, - pub trace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub transfer_bindings: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, - ) -> ::std::os::raw::c_int, - >, - pub update_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub user_data: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, - >, - pub value_blob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_bytes16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_double: ::std::option::Option f64>, - pub value_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_int64: - ::std::option::Option sqlite_int64>, - pub value_numeric_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_text: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, - >, - pub value_text16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16be: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16le: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub vmprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char, - >, - pub overload_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub prepare_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub clear_bindings: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub create_module_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_zeroblob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_close: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, - ) -> ::std::os::raw::c_int, - >, - pub blob_read: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_write: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub create_collation_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub file_control: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub memory_highwater: - ::std::option::Option sqlite3_int64>, - pub memory_used: ::std::option::Option sqlite3_int64>, - pub mutex_alloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub mutex_enter: ::std::option::Option, - pub mutex_free: ::std::option::Option, - pub mutex_leave: ::std::option::Option, - pub mutex_try: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub open_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub release_memory: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub result_error_nomem: ::std::option::Option, - pub result_error_toobig: - ::std::option::Option, - pub sleep: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub soft_heap_limit: ::std::option::Option, - pub vfs_find: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, - >, - pub vfs_register: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub vfs_unregister: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, - >, - pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, - pub result_zeroblob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_error_code: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub test_control: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, - >, - pub randomness: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), - >, - pub context_db_handle: - ::std::option::Option *mut sqlite3>, - pub extended_result_codes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub limit: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub next_stmt: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, - >, - pub sql: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, - >, - pub status: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub backup_finish: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_init: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut sqlite3, - arg4: *const ::std::os::raw::c_char, - ) -> *mut sqlite3_backup, - >, - pub backup_pagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_remaining: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_step: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_backup, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub compileoption_get: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, - >, - pub compileoption_used: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, - pub create_function_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub db_config: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int, - >, - pub db_mutex: - ::std::option::Option *mut sqlite3_mutex>, - pub db_status: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub extended_errcode: - ::std::option::Option ::std::os::raw::c_int>, - pub log: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char, ...), - >, - pub soft_heap_limit64: - ::std::option::Option sqlite3_int64>, - pub sourceid: ::std::option::Option *const ::std::os::raw::c_char>, - pub stmt_status: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub strnicmp: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub unlock_notify: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub wal_autocheckpoint: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub wal_checkpoint: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub wal_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub blob_reopen: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob, arg2: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub vtab_config: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int, - >, - pub vtab_on_conflict: - ::std::option::Option ::std::os::raw::c_int>, - pub close_v2: - ::std::option::Option ::std::os::raw::c_int>, - pub db_filename: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, - pub db_readonly: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub db_release_memory: - ::std::option::Option ::std::os::raw::c_int>, - pub errstr: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, - >, - pub stmt_busy: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub stmt_readonly: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub stricmp: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub uri_boolean: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub uri_int64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_int64, - ) -> sqlite3_int64, - >, - pub uri_parameter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, - pub xvsnprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char, - >, - pub wal_checkpoint_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub auto_extension: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_blob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_text64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - arg6: ::std::os::raw::c_uchar, - ) -> ::std::os::raw::c_int, - >, - pub cancel_auto_extension: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub load_extension: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub malloc64: ::std::option::Option< - unsafe extern "C" fn(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void, - >, - pub msize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64, - >, - pub realloc64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: sqlite3_uint64, - ) -> *mut ::std::os::raw::c_void, - >, - pub reset_auto_extension: ::std::option::Option, - pub result_blob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - ), - >, - pub result_text64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - arg5: ::std::os::raw::c_uchar, - ), - >, - pub strglob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub value_dup: ::std::option::Option< - unsafe extern "C" fn(arg1: *const sqlite3_value) -> *mut sqlite3_value, - >, - pub value_free: ::std::option::Option, - pub result_zeroblob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: sqlite3_uint64, - ) -> ::std::os::raw::c_int, - >, - pub bind_zeroblob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_uint64, - ) -> ::std::os::raw::c_int, - >, - pub value_subtype: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint, - >, - pub result_subtype: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint), - >, - pub status64: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut sqlite3_int64, - arg3: *mut sqlite3_int64, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub strlike: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_uint, - ) -> ::std::os::raw::c_int, - >, - pub db_cacheflush: - ::std::option::Option ::std::os::raw::c_int>, - pub system_errno: - ::std::option::Option ::std::os::raw::c_int>, - pub trace_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_uint, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_uint, - arg2: *mut ::std::os::raw::c_void, - arg3: *mut ::std::os::raw::c_void, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub expanded_sql: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char, - >, - pub set_last_insert_rowid: - ::std::option::Option, - pub prepare_v3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_uint, - arg5: *mut *mut sqlite3_stmt, - arg6: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16_v3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_uint, - arg5: *mut *mut sqlite3_stmt, - arg6: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub bind_pointer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: *const ::std::os::raw::c_char, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub result_pointer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *mut ::std::os::raw::c_void, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::option::Option, - ), - >, - pub value_pointer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_value, - arg2: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void, - >, - pub vtab_nochange: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, - >, - pub value_nochange: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub vtab_collation: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_index_info, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub keyword_count: ::std::option::Option ::std::os::raw::c_int>, - pub keyword_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut *const ::std::os::raw::c_char, - arg3: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub keyword_check: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub str_new: - ::std::option::Option *mut sqlite3_str>, - pub str_finish: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char, - >, - pub str_appendf: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_str, zFormat: *const ::std::os::raw::c_char, ...), - >, - pub str_vappendf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_str, - zFormat: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, - ), - >, - pub str_append: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_str, - zIn: *const ::std::os::raw::c_char, - N: ::std::os::raw::c_int, - ), - >, - pub str_appendall: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_str, zIn: *const ::std::os::raw::c_char), - >, - pub str_appendchar: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_str, - N: ::std::os::raw::c_int, - C: ::std::os::raw::c_char, - ), - >, - pub str_reset: ::std::option::Option, - pub str_errcode: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int, - >, - pub str_length: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int, - >, - pub str_value: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char, - >, - pub create_window_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xValue: ::std::option::Option, - xInv: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub normalized_sql: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_api_routines() { - assert_eq!( - ::std::mem::size_of::(), - 1928usize, - concat!("Size of: ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_context as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_context) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_count as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_double as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_count as *const _ - as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_index as *const _ - as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_index) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_name as *const _ - as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_text16 as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_handler as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_handler) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_timeout as *const _ as usize - }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_timeout) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(close) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed as *const _ as usize - }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_blob as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes as *const _ as usize - }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize - }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_count as *const _ as usize - }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name as *const _ - as usize - }, - 184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name16 as *const _ - as usize - }, - 192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype as *const _ as usize - }, - 200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize - }, - 208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_double as *const _ as usize - }, - 216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, - 224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_int64 as *const _ as usize - }, - 232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name as *const _ as usize - }, - 240usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name16 as *const _ as usize - }, - 248usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name as *const _ as usize - }, - 256usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name16 as *const _ - as usize - }, - 264usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name as *const _ as usize - }, - 272usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name16 as *const _ - as usize - }, - 280usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text as *const _ as usize - }, - 288usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text16 as *const _ as usize - }, - 296usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_type as *const _ as usize - }, - 304usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_type) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_value as *const _ as usize - }, - 312usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).commit_hook as *const _ as usize - }, - 320usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(commit_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, - 328usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, - 336usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation as *const _ as usize - }, - 344usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation16 as *const _ as usize - }, - 352usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function as *const _ as usize - }, - 360usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function16 as *const _ as usize - }, - 368usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module as *const _ as usize - }, - 376usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, - 384usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(data_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, - 392usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).declare_vtab as *const _ as usize - }, - 400usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(declare_vtab) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).enable_shared_cache as *const _ - as usize - }, - 408usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(enable_shared_cache) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, - 416usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, - 424usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, - 432usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, - 440usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(exec) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, - 448usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(expired) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, - 456usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(finalize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, - 464usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, - 472usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_autocommit as *const _ as usize - }, - 480usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_autocommit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_auxdata as *const _ as usize - }, - 488usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, - 496usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).global_recover as *const _ as usize - }, - 504usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(global_recover) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, - 512usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(interruptx) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize - }, - 520usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(last_insert_rowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, - 528usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).libversion_number as *const _ as usize - }, - 536usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion_number) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, - 544usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(malloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, - 552usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, - 560usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, - 568usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, - 576usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, - 584usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, - 592usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(profile) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).progress_handler as *const _ as usize - }, - 600usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(progress_handler) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, - 608usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(realloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, - 616usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(reset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_blob as *const _ as usize - }, - 624usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_double as *const _ as usize - }, - 632usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_double) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error as *const _ as usize - }, - 640usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error16 as *const _ as usize - }, - 648usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, - 656usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_int64 as *const _ as usize - }, - 664usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_null as *const _ as usize - }, - 672usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text as *const _ as usize - }, - 680usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16 as *const _ as usize - }, - 688usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16be as *const _ as usize - }, - 696usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16le as *const _ as usize - }, - 704usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16le) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_value as *const _ as usize - }, - 712usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rollback_hook as *const _ as usize - }, - 720usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(rollback_hook) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_authorizer as *const _ as usize - }, - 728usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_authorizer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_auxdata as *const _ as usize - }, - 736usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xsnprintf as *const _ as usize }, - 744usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(xsnprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, - 752usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(step) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).table_column_metadata as *const _ - as usize - }, - 760usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(table_column_metadata) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize - }, - 768usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(thread_cleanup) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).total_changes as *const _ as usize - }, - 776usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(total_changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, - 784usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(trace) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize - }, - 792usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(transfer_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).update_hook as *const _ as usize - }, - 800usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(update_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, - 808usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(user_data) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, - 816usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes as *const _ as usize - }, - 824usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize - }, - 832usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_double as *const _ as usize - }, - 840usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, - 848usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_int64 as *const _ as usize - }, - 856usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize - }, - 864usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_numeric_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, - 872usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16 as *const _ as usize - }, - 880usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16be as *const _ as usize - }, - 888usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16le as *const _ as usize - }, - 896usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16le) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, - 904usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, - 912usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vmprintf) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).overload_function as *const _ as usize - }, - 920usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(overload_function) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, - 928usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize - }, - 936usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).clear_bindings as *const _ as usize - }, - 944usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(clear_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize - }, - 952usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize - }, - 960usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_zeroblob) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, - 968usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_bytes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, - 976usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_close) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, - 984usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, - 992usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_read) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, - 1000usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_write) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation_v2 as *const _ - as usize - }, - 1008usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).file_control as *const _ as usize - }, - 1016usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(file_control) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_highwater as *const _ as usize - }, - 1024usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_highwater) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_used as *const _ as usize - }, - 1032usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_used) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize - }, - 1040usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_alloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_enter as *const _ as usize - }, - 1048usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_enter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, - 1056usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_free) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_leave as *const _ as usize - }, - 1064usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_leave) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, - 1072usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_try) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, - 1080usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).release_memory as *const _ as usize - }, - 1088usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(release_memory) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize - }, - 1096usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_nomem) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_toobig as *const _ - as usize - }, - 1104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_toobig) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, - 1112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sleep) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize - }, - 1120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(soft_heap_limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, - 1128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_find) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_register as *const _ as usize - }, - 1136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_register) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize - }, - 1144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_unregister) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize - }, - 1152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(xthreadsafe) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize - }, - 1160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_zeroblob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_code as *const _ as usize - }, - 1168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_code) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).test_control as *const _ as usize - }, - 1176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(test_control) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, - 1184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(randomness) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).context_db_handle as *const _ as usize - }, - 1192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(context_db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).extended_result_codes as *const _ - as usize - }, - 1200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(extended_result_codes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, - 1208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, - 1216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(next_stmt) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, - 1224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sql) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, - 1232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(status) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_finish as *const _ as usize - }, - 1240usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_finish) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_init as *const _ as usize - }, - 1248usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_init) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_pagecount as *const _ as usize - }, - 1256usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_pagecount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_remaining as *const _ as usize - }, - 1264usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_remaining) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_step as *const _ as usize - }, - 1272usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_step) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).compileoption_get as *const _ as usize - }, - 1280usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(compileoption_get) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).compileoption_used as *const _ as usize - }, - 1288usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(compileoption_used) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function_v2 as *const _ as usize - }, - 1296usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function_v2) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_config as *const _ as usize }, - 1304usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_config) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_mutex as *const _ as usize }, - 1312usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_mutex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_status as *const _ as usize }, - 1320usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_status) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).extended_errcode as *const _ as usize - }, - 1328usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(extended_errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).log as *const _ as usize }, - 1336usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(log) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).soft_heap_limit64 as *const _ as usize - }, - 1344usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(soft_heap_limit64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sourceid as *const _ as usize }, - 1352usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sourceid) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stmt_status as *const _ as usize - }, - 1360usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_status) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).strnicmp as *const _ as usize }, - 1368usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(strnicmp) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).unlock_notify as *const _ as usize - }, - 1376usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(unlock_notify) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_autocheckpoint as *const _ as usize - }, - 1384usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_autocheckpoint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_checkpoint as *const _ as usize - }, - 1392usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_checkpoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).wal_hook as *const _ as usize }, - 1400usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_hook) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).blob_reopen as *const _ as usize - }, - 1408usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_reopen) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtab_config as *const _ as usize - }, - 1416usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vtab_config) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtab_on_conflict as *const _ as usize - }, - 1424usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vtab_on_conflict) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).close_v2 as *const _ as usize }, - 1432usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(close_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_filename as *const _ as usize - }, - 1440usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_filename) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_readonly as *const _ as usize - }, - 1448usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_readonly) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_release_memory as *const _ as usize - }, - 1456usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_release_memory) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errstr as *const _ as usize }, - 1464usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errstr) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).stmt_busy as *const _ as usize }, - 1472usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_busy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stmt_readonly as *const _ as usize - }, - 1480usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_readonly) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).stricmp as *const _ as usize }, - 1488usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stricmp) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).uri_boolean as *const _ as usize - }, - 1496usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(uri_boolean) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).uri_int64 as *const _ as usize }, - 1504usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(uri_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).uri_parameter as *const _ as usize - }, - 1512usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(uri_parameter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xvsnprintf as *const _ as usize }, - 1520usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(xvsnprintf) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_checkpoint_v2 as *const _ as usize - }, - 1528usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_checkpoint_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).auto_extension as *const _ as usize - }, - 1536usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(auto_extension) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_blob64 as *const _ as usize - }, - 1544usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_blob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_text64 as *const _ as usize - }, - 1552usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).cancel_auto_extension as *const _ - as usize - }, - 1560usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(cancel_auto_extension) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).load_extension as *const _ as usize - }, - 1568usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(load_extension) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).malloc64 as *const _ as usize }, - 1576usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(malloc64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).msize as *const _ as usize }, - 1584usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(msize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).realloc64 as *const _ as usize }, - 1592usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(realloc64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).reset_auto_extension as *const _ - as usize - }, - 1600usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(reset_auto_extension) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_blob64 as *const _ as usize - }, - 1608usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_blob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text64 as *const _ as usize - }, - 1616usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).strglob as *const _ as usize }, - 1624usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(strglob) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_dup as *const _ as usize }, - 1632usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_dup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_free as *const _ as usize }, - 1640usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_free) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_zeroblob64 as *const _ as usize - }, - 1648usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_zeroblob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_zeroblob64 as *const _ as usize - }, - 1656usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_zeroblob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_subtype as *const _ as usize - }, - 1664usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_subtype) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_subtype as *const _ as usize - }, - 1672usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_subtype) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).status64 as *const _ as usize }, - 1680usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(status64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).strlike as *const _ as usize }, - 1688usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(strlike) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_cacheflush as *const _ as usize - }, - 1696usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_cacheflush) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).system_errno as *const _ as usize - }, - 1704usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(system_errno) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).trace_v2 as *const _ as usize }, - 1712usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(trace_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).expanded_sql as *const _ as usize - }, - 1720usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(expanded_sql) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_last_insert_rowid as *const _ - as usize - }, - 1728usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_last_insert_rowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare_v3 as *const _ as usize }, - 1736usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare_v3) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).prepare16_v3 as *const _ as usize - }, - 1744usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16_v3) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_pointer as *const _ as usize - }, - 1752usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_pointer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_pointer as *const _ as usize - }, - 1760usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_pointer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_pointer as *const _ as usize - }, - 1768usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_pointer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtab_nochange as *const _ as usize - }, - 1776usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vtab_nochange) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_nochange as *const _ as usize - }, - 1784usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_nochange) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtab_collation as *const _ as usize - }, - 1792usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vtab_collation) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).keyword_count as *const _ as usize - }, - 1800usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(keyword_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).keyword_name as *const _ as usize - }, - 1808usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(keyword_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).keyword_check as *const _ as usize - }, - 1816usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(keyword_check) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).str_new as *const _ as usize }, - 1824usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_new) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).str_finish as *const _ as usize }, - 1832usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_finish) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).str_appendf as *const _ as usize - }, - 1840usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_appendf) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).str_vappendf as *const _ as usize - }, - 1848usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_vappendf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).str_append as *const _ as usize }, - 1856usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_append) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).str_appendall as *const _ as usize - }, - 1864usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_appendall) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).str_appendchar as *const _ as usize - }, - 1872usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_appendchar) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).str_reset as *const _ as usize }, - 1880usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_reset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).str_errcode as *const _ as usize - }, - 1888usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).str_length as *const _ as usize }, - 1896usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_length) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).str_value as *const _ as usize }, - 1904usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_window_function as *const _ - as usize - }, - 1912usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_window_function) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).normalized_sql as *const _ as usize - }, - 1920usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(normalized_sql) - ) - ); -} -pub type sqlite3_loadext_entry = ::std::option::Option< - unsafe extern "C" fn( - db: *mut sqlite3, - pzErrMsg: *mut *mut ::std::os::raw::c_char, - pThunk: *const sqlite3_api_routines, - ) -> ::std::os::raw::c_int, ->; -pub type __builtin_va_list = [__va_list_tag; 1usize]; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct __va_list_tag { - pub gp_offset: ::std::os::raw::c_uint, - pub fp_offset: ::std::os::raw::c_uint, - pub overflow_arg_area: *mut ::std::os::raw::c_void, - pub reg_save_area: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout___va_list_tag() { - assert_eq!( - ::std::mem::size_of::<__va_list_tag>(), - 24usize, - concat!("Size of: ", stringify!(__va_list_tag)) - ); - assert_eq!( - ::std::mem::align_of::<__va_list_tag>(), - 8usize, - concat!("Alignment of ", stringify!(__va_list_tag)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(gp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(fp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(overflow_arg_area) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(reg_save_area) - ) - ); -} - -// bindings were built with (non-embedded) loadable_extension: -// we define our own sqlite_api static variable and export it -// to C -#[no_mangle] -pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_routines; - -// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) - -pub unsafe fn sqlite3_aggregate_context( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_context.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_context", - " function" - )))(arg1, nBytes) -} - -pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_blob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_blob", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_double( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_double", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_null( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_null", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_parameter_index( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_index.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_index", - " function" - )))(arg1, zName) -} - -pub unsafe fn sqlite3_bind_parameter_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_text( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_text16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_bind_value( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_value", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_handler( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_handler", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_timeout( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_timeout.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_timeout", - " function" - )))(arg1, ms) -} - -pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_collation_needed( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_collation_needed16( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_column_blob( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_blob", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_column_database_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_database_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_decltype( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype", - " function" - )))(arg1, i) -} - -pub unsafe fn sqlite3_column_decltype16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_double", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int64( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int64", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_text( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_text16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_type( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_type", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_value( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_value", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_commit_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).commit_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "commit_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete16", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_create_collation( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_collation16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_function( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_function16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function16", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_module( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).data_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "data_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_declare_vtab( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).declare_vtab.expect(stringify!( - "sqlite3_api contains null pointer for ", - "declare_vtab", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).enable_shared_cache.expect(stringify!( - "sqlite3_api contains null pointer for ", - "enable_shared_cache", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errcode", - " function" - )))(db) -} - -pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_exec( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).exec.expect(stringify!( - "sqlite3_api contains null pointer for ", - "exec", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).expired.expect(stringify!( - "sqlite3_api contains null pointer for ", - "expired", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).finalize.expect(stringify!( - "sqlite3_api contains null pointer for ", - "finalize", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free_table", - " function" - )))(result) -} - -pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_autocommit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_autocommit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_get_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_auxdata", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_get_table( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_table", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).global_recover.expect(stringify!( - "sqlite3_api contains null pointer for ", - "global_recover", - " function" - )))() -} - -pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).interruptx.expect(stringify!( - "sqlite3_api contains null pointer for ", - "interruptx", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).last_insert_rowid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "last_insert_rowid", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion", - " function" - )))() -} - -pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion_number.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion_number", - " function" - )))() -} - -pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).malloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "malloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mprintf( - arg1: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mprintf", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_open( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_open16( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_prepare( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_profile( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).profile.expect(stringify!( - "sqlite3_api contains null pointer for ", - "profile", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_progress_handler( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).progress_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "progress_handler", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_realloc( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).realloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "realloc", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).reset.expect(stringify!( - "sqlite3_api contains null pointer for ", - "reset", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_result_blob( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_blob", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_double", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_error16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_null", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_text( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16be( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16be", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16le( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16le", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_value", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_rollback_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).rollback_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "rollback_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_authorizer( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_authorizer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_authorizer", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_auxdata", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_xsnprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).xsnprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "xsnprintf", - " function" - )))(arg1, arg2, arg3, vararg1) -} - -pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).step.expect(stringify!( - "sqlite3_api contains null pointer for ", - "step", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_table_column_metadata( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).table_column_metadata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "table_column_metadata", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) -} - -pub unsafe fn sqlite3_thread_cleanup() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).thread_cleanup.expect(stringify!( - "sqlite3_api contains null pointer for ", - "thread_cleanup", - " function" - )))() -} - -pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).total_changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "total_changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_trace( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).trace.expect(stringify!( - "sqlite3_api contains null pointer for ", - "trace", - " function" - )))(arg1, xTrace, arg2) -} - -pub unsafe fn sqlite3_transfer_bindings( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).transfer_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "transfer_bindings", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_update_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).update_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "update_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).user_data.expect(stringify!( - "sqlite3_api contains null pointer for ", - "user_data", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_blob", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_double", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_numeric_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_numeric_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16be", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16le", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vmprintf( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vmprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vmprintf", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_overload_function( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).overload_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "overload_function", - " function" - )))(arg1, zFuncName, nArg) -} - -pub unsafe fn sqlite3_prepare_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).clear_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "clear_bindings", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_module_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module_v2", - " function" - )))(arg1, arg2, arg3, arg4, xDestroy) -} - -pub unsafe fn sqlite3_bind_zeroblob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_zeroblob", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_open( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_open", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) -} - -pub unsafe fn sqlite3_blob_read( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_read.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_read", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_blob_write( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_write.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_write", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_create_collation_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_file_control( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).file_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "file_control", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_highwater.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_highwater", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_used.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_used", - " function" - )))() -} - -pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_alloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_alloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_enter.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_enter", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_leave.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_leave", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_try.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_try", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_open_v2( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open_v2", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).release_memory.expect(stringify!( - "sqlite3_api contains null pointer for ", - "release_memory", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_nomem.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_nomem", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_toobig.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_toobig", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sleep.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sleep", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).soft_heap_limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "soft_heap_limit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_find.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_find", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_register( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_register.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_register", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_unregister.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_unregister", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).xthreadsafe.expect(stringify!( - "sqlite3_api contains null pointer for ", - "xthreadsafe", - " function" - )))() -} - -pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_zeroblob", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_code.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_code", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_test_control( - arg1: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).test_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "test_control", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).randomness.expect(stringify!( - "sqlite3_api contains null pointer for ", - "randomness", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).context_db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "context_db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_extended_result_codes( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).extended_result_codes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "extended_result_codes", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_limit( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "limit", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).next_stmt.expect(stringify!( - "sqlite3_api contains null pointer for ", - "next_stmt", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sql.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sql", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_status( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "status", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_finish.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_finish", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_init( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut sqlite3, - arg4: *const ::std::os::raw::c_char, -) -> *mut sqlite3_backup { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_init.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_init", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_pagecount.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_pagecount", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_remaining.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_remaining", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_step( - arg1: *mut sqlite3_backup, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_step.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_step", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_compileoption_get( - arg1: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).compileoption_get.expect(stringify!( - "sqlite3_api contains null pointer for ", - "compileoption_get", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_compileoption_used( - arg1: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).compileoption_used.expect(stringify!( - "sqlite3_api contains null pointer for ", - "compileoption_used", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_function_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal, xDestroy) -} - -pub unsafe fn sqlite3_db_config( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, - vararg2: &mut i32, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_config.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_config", - " function" - )))(arg1, arg2, vararg1, vararg2) -} - -pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_mutex.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_mutex", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_db_status( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_status", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).extended_errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "extended_errcode", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_log( - arg1: ::std::os::raw::c_int, - arg2: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).log.expect(stringify!( - "sqlite3_api contains null pointer for ", - "log", - " function" - )))(arg1, arg2, vararg1) -} - -pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).soft_heap_limit64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "soft_heap_limit64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sourceid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sourceid", - " function" - )))() -} - -pub unsafe fn sqlite3_stmt_status( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_status", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_strnicmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).strnicmp.expect(stringify!( - "sqlite3_api contains null pointer for ", - "strnicmp", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_unlock_notify( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int), - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).unlock_notify.expect(stringify!( - "sqlite3_api contains null pointer for ", - "unlock_notify", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_wal_autocheckpoint( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_autocheckpoint", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_wal_checkpoint( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_checkpoint.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_checkpoint", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_wal_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_blob_reopen( - arg1: *mut sqlite3_blob, - arg2: sqlite3_int64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_reopen.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_reopen", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vtab_config( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vtab_config.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vtab_config", - " function" - )))(arg1, op, vararg1) -} - -pub unsafe fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vtab_on_conflict.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vtab_on_conflict", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "close_v2", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_db_filename( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_filename.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_filename", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_db_readonly( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_readonly.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_readonly", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_release_memory.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_release_memory", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errstr.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errstr", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_busy.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_busy", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_stmt_readonly(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_readonly.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_readonly", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_stricmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stricmp.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stricmp", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_uri_boolean( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).uri_boolean.expect(stringify!( - "sqlite3_api contains null pointer for ", - "uri_boolean", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_uri_int64( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_int64, -) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).uri_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "uri_int64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_uri_parameter( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).uri_parameter.expect(stringify!( - "sqlite3_api contains null pointer for ", - "uri_parameter", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_xvsnprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut __va_list_tag, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).xvsnprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "xvsnprintf", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_wal_checkpoint_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_checkpoint_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_checkpoint_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_auto_extension( - arg1: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).auto_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "auto_extension", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_blob64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_blob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_blob64", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_bind_text64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - arg6: ::std::os::raw::c_uchar, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text64", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_cancel_auto_extension( - arg1: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).cancel_auto_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "cancel_auto_extension", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_load_extension( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).load_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "load_extension", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_malloc64(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).malloc64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "malloc64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_msize(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).msize.expect(stringify!( - "sqlite3_api contains null pointer for ", - "msize", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_realloc64( - arg1: *mut ::std::os::raw::c_void, - arg2: sqlite3_uint64, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).realloc64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "realloc64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_reset_auto_extension() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).reset_auto_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "reset_auto_extension", - " function" - )))() -} - -pub unsafe fn sqlite3_result_blob64( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_blob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_blob64", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text64( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - arg5: ::std::os::raw::c_uchar, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text64", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_strglob( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).strglob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "strglob", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_value_dup(arg1: *const sqlite3_value) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_dup.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_dup", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_free(arg1: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_zeroblob64( - arg1: *mut sqlite3_context, - arg2: sqlite3_uint64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_zeroblob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_zeroblob64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_zeroblob64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_uint64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_zeroblob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_zeroblob64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_value_subtype(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_subtype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_subtype", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_subtype(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_subtype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_subtype", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_status64( - arg1: ::std::os::raw::c_int, - arg2: *mut sqlite3_int64, - arg3: *mut sqlite3_int64, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).status64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "status64", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_strlike( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_uint, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).strlike.expect(stringify!( - "sqlite3_api contains null pointer for ", - "strlike", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_db_cacheflush(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_cacheflush.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_cacheflush", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_system_errno(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).system_errno.expect(stringify!( - "sqlite3_api contains null pointer for ", - "system_errno", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_trace_v2( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_uint, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_uint, - arg2: *mut ::std::os::raw::c_void, - arg3: *mut ::std::os::raw::c_void, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).trace_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "trace_v2", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_expanded_sql(arg1: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).expanded_sql.expect(stringify!( - "sqlite3_api contains null pointer for ", - "expanded_sql", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_set_last_insert_rowid(arg1: *mut sqlite3, arg2: sqlite3_int64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_last_insert_rowid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_last_insert_rowid", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_prepare_v3( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_uint, - arg5: *mut *mut sqlite3_stmt, - arg6: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare_v3.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare_v3", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_prepare16_v3( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_uint, - arg5: *mut *mut sqlite3_stmt, - arg6: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16_v3.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16_v3", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_bind_pointer( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: *const ::std::os::raw::c_char, - arg5: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_pointer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_pointer", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_result_pointer( - arg1: *mut sqlite3_context, - arg2: *mut ::std::os::raw::c_void, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_pointer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_pointer", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_value_pointer( - arg1: *mut sqlite3_value, - arg2: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_pointer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_pointer", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vtab_nochange(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vtab_nochange.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vtab_nochange", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_nochange(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_nochange.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_nochange", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vtab_collation( - arg1: *mut sqlite3_index_info, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vtab_collation.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vtab_collation", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_keyword_count() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).keyword_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "keyword_count", - " function" - )))() -} - -pub unsafe fn sqlite3_keyword_name( - arg1: ::std::os::raw::c_int, - arg2: *mut *const ::std::os::raw::c_char, - arg3: *mut ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).keyword_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "keyword_name", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_keyword_check( - arg1: *const ::std::os::raw::c_char, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).keyword_check.expect(stringify!( - "sqlite3_api contains null pointer for ", - "keyword_check", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_str_new(arg1: *mut sqlite3) -> *mut sqlite3_str { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_new.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_new", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_str_finish(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_finish.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_finish", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_str_appendf( - arg1: *mut sqlite3_str, - zFormat: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_appendf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_appendf", - " function" - )))(arg1, zFormat, vararg1) -} - -pub unsafe fn sqlite3_str_vappendf( - arg1: *mut sqlite3_str, - zFormat: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_vappendf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_vappendf", - " function" - )))(arg1, zFormat, arg2) -} - -pub unsafe fn sqlite3_str_append( - arg1: *mut sqlite3_str, - zIn: *const ::std::os::raw::c_char, - N: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_append.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_append", - " function" - )))(arg1, zIn, N) -} - -pub unsafe fn sqlite3_str_appendall(arg1: *mut sqlite3_str, zIn: *const ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_appendall.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_appendall", - " function" - )))(arg1, zIn) -} - -pub unsafe fn sqlite3_str_appendchar( - arg1: *mut sqlite3_str, - N: ::std::os::raw::c_int, - C: ::std::os::raw::c_char, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_appendchar.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_appendchar", - " function" - )))(arg1, N, C) -} - -pub unsafe fn sqlite3_str_reset(arg1: *mut sqlite3_str) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_reset.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_reset", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_str_errcode(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_errcode", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_str_length(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_length.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_length", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_str_value(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_value", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_window_function( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xValue: ::std::option::Option, - xInv: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_window_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_window_function", - " function" - )))( - arg1, arg2, arg3, arg4, arg5, xStep, xFinal, xValue, xInv, xDestroy, - ) -} - -pub unsafe fn sqlite3_normalized_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).normalized_sql.expect(stringify!( - "sqlite3_api contains null pointer for ", - "normalized_sql", - " function" - )))(arg1) -} diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.26.0.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.26.0.rs deleted file mode 100644 index 95fe191fe..000000000 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.26.0.rs +++ /dev/null @@ -1,5225 +0,0 @@ -/* automatically generated by rust-bindgen */ - -pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.26.0\0"; -pub const SQLITE_VERSION_NUMBER: i32 = 3026000; -pub const SQLITE_SOURCE_ID: &'static [u8; 85usize] = - b"2018-12-01 12:34:55 bf8c1b2b7a5960c282e543b9c293686dccff272512d08865f4600fb58238b4f9\0"; -pub const SQLITE_OK: i32 = 0; -pub const SQLITE_ERROR: i32 = 1; -pub const SQLITE_INTERNAL: i32 = 2; -pub const SQLITE_PERM: i32 = 3; -pub const SQLITE_ABORT: i32 = 4; -pub const SQLITE_BUSY: i32 = 5; -pub const SQLITE_LOCKED: i32 = 6; -pub const SQLITE_NOMEM: i32 = 7; -pub const SQLITE_READONLY: i32 = 8; -pub const SQLITE_INTERRUPT: i32 = 9; -pub const SQLITE_IOERR: i32 = 10; -pub const SQLITE_CORRUPT: i32 = 11; -pub const SQLITE_NOTFOUND: i32 = 12; -pub const SQLITE_FULL: i32 = 13; -pub const SQLITE_CANTOPEN: i32 = 14; -pub const SQLITE_PROTOCOL: i32 = 15; -pub const SQLITE_EMPTY: i32 = 16; -pub const SQLITE_SCHEMA: i32 = 17; -pub const SQLITE_TOOBIG: i32 = 18; -pub const SQLITE_CONSTRAINT: i32 = 19; -pub const SQLITE_MISMATCH: i32 = 20; -pub const SQLITE_MISUSE: i32 = 21; -pub const SQLITE_NOLFS: i32 = 22; -pub const SQLITE_AUTH: i32 = 23; -pub const SQLITE_FORMAT: i32 = 24; -pub const SQLITE_RANGE: i32 = 25; -pub const SQLITE_NOTADB: i32 = 26; -pub const SQLITE_NOTICE: i32 = 27; -pub const SQLITE_WARNING: i32 = 28; -pub const SQLITE_ROW: i32 = 100; -pub const SQLITE_DONE: i32 = 101; -pub const SQLITE_ERROR_MISSING_COLLSEQ: i32 = 257; -pub const SQLITE_ERROR_RETRY: i32 = 513; -pub const SQLITE_ERROR_SNAPSHOT: i32 = 769; -pub const SQLITE_IOERR_READ: i32 = 266; -pub const SQLITE_IOERR_SHORT_READ: i32 = 522; -pub const SQLITE_IOERR_WRITE: i32 = 778; -pub const SQLITE_IOERR_FSYNC: i32 = 1034; -pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; -pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; -pub const SQLITE_IOERR_FSTAT: i32 = 1802; -pub const SQLITE_IOERR_UNLOCK: i32 = 2058; -pub const SQLITE_IOERR_RDLOCK: i32 = 2314; -pub const SQLITE_IOERR_DELETE: i32 = 2570; -pub const SQLITE_IOERR_BLOCKED: i32 = 2826; -pub const SQLITE_IOERR_NOMEM: i32 = 3082; -pub const SQLITE_IOERR_ACCESS: i32 = 3338; -pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; -pub const SQLITE_IOERR_LOCK: i32 = 3850; -pub const SQLITE_IOERR_CLOSE: i32 = 4106; -pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; -pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; -pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; -pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; -pub const SQLITE_IOERR_SHMMAP: i32 = 5386; -pub const SQLITE_IOERR_SEEK: i32 = 5642; -pub const SQLITE_IOERR_DELETE_NOENT: i32 = 5898; -pub const SQLITE_IOERR_MMAP: i32 = 6154; -pub const SQLITE_IOERR_GETTEMPPATH: i32 = 6410; -pub const SQLITE_IOERR_CONVPATH: i32 = 6666; -pub const SQLITE_IOERR_VNODE: i32 = 6922; -pub const SQLITE_IOERR_AUTH: i32 = 7178; -pub const SQLITE_IOERR_BEGIN_ATOMIC: i32 = 7434; -pub const SQLITE_IOERR_COMMIT_ATOMIC: i32 = 7690; -pub const SQLITE_IOERR_ROLLBACK_ATOMIC: i32 = 7946; -pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; -pub const SQLITE_LOCKED_VTAB: i32 = 518; -pub const SQLITE_BUSY_RECOVERY: i32 = 261; -pub const SQLITE_BUSY_SNAPSHOT: i32 = 517; -pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; -pub const SQLITE_CANTOPEN_ISDIR: i32 = 526; -pub const SQLITE_CANTOPEN_FULLPATH: i32 = 782; -pub const SQLITE_CANTOPEN_CONVPATH: i32 = 1038; -pub const SQLITE_CANTOPEN_DIRTYWAL: i32 = 1294; -pub const SQLITE_CORRUPT_VTAB: i32 = 267; -pub const SQLITE_CORRUPT_SEQUENCE: i32 = 523; -pub const SQLITE_READONLY_RECOVERY: i32 = 264; -pub const SQLITE_READONLY_CANTLOCK: i32 = 520; -pub const SQLITE_READONLY_ROLLBACK: i32 = 776; -pub const SQLITE_READONLY_DBMOVED: i32 = 1032; -pub const SQLITE_READONLY_CANTINIT: i32 = 1288; -pub const SQLITE_READONLY_DIRECTORY: i32 = 1544; -pub const SQLITE_ABORT_ROLLBACK: i32 = 516; -pub const SQLITE_CONSTRAINT_CHECK: i32 = 275; -pub const SQLITE_CONSTRAINT_COMMITHOOK: i32 = 531; -pub const SQLITE_CONSTRAINT_FOREIGNKEY: i32 = 787; -pub const SQLITE_CONSTRAINT_FUNCTION: i32 = 1043; -pub const SQLITE_CONSTRAINT_NOTNULL: i32 = 1299; -pub const SQLITE_CONSTRAINT_PRIMARYKEY: i32 = 1555; -pub const SQLITE_CONSTRAINT_TRIGGER: i32 = 1811; -pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067; -pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323; -pub const SQLITE_CONSTRAINT_ROWID: i32 = 2579; -pub const SQLITE_NOTICE_RECOVER_WAL: i32 = 283; -pub const SQLITE_NOTICE_RECOVER_ROLLBACK: i32 = 539; -pub const SQLITE_WARNING_AUTOINDEX: i32 = 284; -pub const SQLITE_AUTH_USER: i32 = 279; -pub const SQLITE_OK_LOAD_PERMANENTLY: i32 = 256; -pub const SQLITE_OPEN_READONLY: i32 = 1; -pub const SQLITE_OPEN_READWRITE: i32 = 2; -pub const SQLITE_OPEN_CREATE: i32 = 4; -pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; -pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; -pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; -pub const SQLITE_OPEN_URI: i32 = 64; -pub const SQLITE_OPEN_MEMORY: i32 = 128; -pub const SQLITE_OPEN_MAIN_DB: i32 = 256; -pub const SQLITE_OPEN_TEMP_DB: i32 = 512; -pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; -pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; -pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; -pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; -pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; -pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; -pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; -pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; -pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; -pub const SQLITE_OPEN_WAL: i32 = 524288; -pub const SQLITE_IOCAP_ATOMIC: i32 = 1; -pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; -pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; -pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; -pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; -pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; -pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; -pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; -pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; -pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; -pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; -pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; -pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE: i32 = 4096; -pub const SQLITE_IOCAP_IMMUTABLE: i32 = 8192; -pub const SQLITE_IOCAP_BATCH_ATOMIC: i32 = 16384; -pub const SQLITE_LOCK_NONE: i32 = 0; -pub const SQLITE_LOCK_SHARED: i32 = 1; -pub const SQLITE_LOCK_RESERVED: i32 = 2; -pub const SQLITE_LOCK_PENDING: i32 = 3; -pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; -pub const SQLITE_SYNC_NORMAL: i32 = 2; -pub const SQLITE_SYNC_FULL: i32 = 3; -pub const SQLITE_SYNC_DATAONLY: i32 = 16; -pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; -pub const SQLITE_FCNTL_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_FCNTL_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_FCNTL_LAST_ERRNO: i32 = 4; -pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; -pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; -pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; -pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; -pub const SQLITE_FCNTL_WIN32_AV_RETRY: i32 = 9; -pub const SQLITE_FCNTL_PERSIST_WAL: i32 = 10; -pub const SQLITE_FCNTL_OVERWRITE: i32 = 11; -pub const SQLITE_FCNTL_VFSNAME: i32 = 12; -pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE: i32 = 13; -pub const SQLITE_FCNTL_PRAGMA: i32 = 14; -pub const SQLITE_FCNTL_BUSYHANDLER: i32 = 15; -pub const SQLITE_FCNTL_TEMPFILENAME: i32 = 16; -pub const SQLITE_FCNTL_MMAP_SIZE: i32 = 18; -pub const SQLITE_FCNTL_TRACE: i32 = 19; -pub const SQLITE_FCNTL_HAS_MOVED: i32 = 20; -pub const SQLITE_FCNTL_SYNC: i32 = 21; -pub const SQLITE_FCNTL_COMMIT_PHASETWO: i32 = 22; -pub const SQLITE_FCNTL_WIN32_SET_HANDLE: i32 = 23; -pub const SQLITE_FCNTL_WAL_BLOCK: i32 = 24; -pub const SQLITE_FCNTL_ZIPVFS: i32 = 25; -pub const SQLITE_FCNTL_RBU: i32 = 26; -pub const SQLITE_FCNTL_VFS_POINTER: i32 = 27; -pub const SQLITE_FCNTL_JOURNAL_POINTER: i32 = 28; -pub const SQLITE_FCNTL_WIN32_GET_HANDLE: i32 = 29; -pub const SQLITE_FCNTL_PDB: i32 = 30; -pub const SQLITE_FCNTL_BEGIN_ATOMIC_WRITE: i32 = 31; -pub const SQLITE_FCNTL_COMMIT_ATOMIC_WRITE: i32 = 32; -pub const SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE: i32 = 33; -pub const SQLITE_FCNTL_LOCK_TIMEOUT: i32 = 34; -pub const SQLITE_FCNTL_DATA_VERSION: i32 = 35; -pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_LAST_ERRNO: i32 = 4; -pub const SQLITE_ACCESS_EXISTS: i32 = 0; -pub const SQLITE_ACCESS_READWRITE: i32 = 1; -pub const SQLITE_ACCESS_READ: i32 = 2; -pub const SQLITE_SHM_UNLOCK: i32 = 1; -pub const SQLITE_SHM_LOCK: i32 = 2; -pub const SQLITE_SHM_SHARED: i32 = 4; -pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; -pub const SQLITE_SHM_NLOCK: i32 = 8; -pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; -pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; -pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; -pub const SQLITE_CONFIG_MALLOC: i32 = 4; -pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; -pub const SQLITE_CONFIG_SCRATCH: i32 = 6; -pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; -pub const SQLITE_CONFIG_HEAP: i32 = 8; -pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; -pub const SQLITE_CONFIG_MUTEX: i32 = 10; -pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; -pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; -pub const SQLITE_CONFIG_PCACHE: i32 = 14; -pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; -pub const SQLITE_CONFIG_LOG: i32 = 16; -pub const SQLITE_CONFIG_URI: i32 = 17; -pub const SQLITE_CONFIG_PCACHE2: i32 = 18; -pub const SQLITE_CONFIG_GETPCACHE2: i32 = 19; -pub const SQLITE_CONFIG_COVERING_INDEX_SCAN: i32 = 20; -pub const SQLITE_CONFIG_SQLLOG: i32 = 21; -pub const SQLITE_CONFIG_MMAP_SIZE: i32 = 22; -pub const SQLITE_CONFIG_WIN32_HEAPSIZE: i32 = 23; -pub const SQLITE_CONFIG_PCACHE_HDRSZ: i32 = 24; -pub const SQLITE_CONFIG_PMASZ: i32 = 25; -pub const SQLITE_CONFIG_STMTJRNL_SPILL: i32 = 26; -pub const SQLITE_CONFIG_SMALL_MALLOC: i32 = 27; -pub const SQLITE_CONFIG_SORTERREF_SIZE: i32 = 28; -pub const SQLITE_DBCONFIG_MAINDBNAME: i32 = 1000; -pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; -pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; -pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; -pub const SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: i32 = 1004; -pub const SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: i32 = 1005; -pub const SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE: i32 = 1006; -pub const SQLITE_DBCONFIG_ENABLE_QPSG: i32 = 1007; -pub const SQLITE_DBCONFIG_TRIGGER_EQP: i32 = 1008; -pub const SQLITE_DBCONFIG_RESET_DATABASE: i32 = 1009; -pub const SQLITE_DBCONFIG_DEFENSIVE: i32 = 1010; -pub const SQLITE_DBCONFIG_MAX: i32 = 1010; -pub const SQLITE_DENY: i32 = 1; -pub const SQLITE_IGNORE: i32 = 2; -pub const SQLITE_CREATE_INDEX: i32 = 1; -pub const SQLITE_CREATE_TABLE: i32 = 2; -pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; -pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; -pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; -pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; -pub const SQLITE_CREATE_TRIGGER: i32 = 7; -pub const SQLITE_CREATE_VIEW: i32 = 8; -pub const SQLITE_DELETE: i32 = 9; -pub const SQLITE_DROP_INDEX: i32 = 10; -pub const SQLITE_DROP_TABLE: i32 = 11; -pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; -pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; -pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; -pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; -pub const SQLITE_DROP_TRIGGER: i32 = 16; -pub const SQLITE_DROP_VIEW: i32 = 17; -pub const SQLITE_INSERT: i32 = 18; -pub const SQLITE_PRAGMA: i32 = 19; -pub const SQLITE_READ: i32 = 20; -pub const SQLITE_SELECT: i32 = 21; -pub const SQLITE_TRANSACTION: i32 = 22; -pub const SQLITE_UPDATE: i32 = 23; -pub const SQLITE_ATTACH: i32 = 24; -pub const SQLITE_DETACH: i32 = 25; -pub const SQLITE_ALTER_TABLE: i32 = 26; -pub const SQLITE_REINDEX: i32 = 27; -pub const SQLITE_ANALYZE: i32 = 28; -pub const SQLITE_CREATE_VTABLE: i32 = 29; -pub const SQLITE_DROP_VTABLE: i32 = 30; -pub const SQLITE_FUNCTION: i32 = 31; -pub const SQLITE_SAVEPOINT: i32 = 32; -pub const SQLITE_COPY: i32 = 0; -pub const SQLITE_RECURSIVE: i32 = 33; -pub const SQLITE_TRACE_STMT: i32 = 1; -pub const SQLITE_TRACE_PROFILE: i32 = 2; -pub const SQLITE_TRACE_ROW: i32 = 4; -pub const SQLITE_TRACE_CLOSE: i32 = 8; -pub const SQLITE_LIMIT_LENGTH: i32 = 0; -pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; -pub const SQLITE_LIMIT_COLUMN: i32 = 2; -pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; -pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; -pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; -pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; -pub const SQLITE_LIMIT_ATTACHED: i32 = 7; -pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; -pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; -pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; -pub const SQLITE_LIMIT_WORKER_THREADS: i32 = 11; -pub const SQLITE_PREPARE_PERSISTENT: i32 = 1; -pub const SQLITE_PREPARE_NORMALIZE: i32 = 2; -pub const SQLITE_INTEGER: i32 = 1; -pub const SQLITE_FLOAT: i32 = 2; -pub const SQLITE_BLOB: i32 = 4; -pub const SQLITE_NULL: i32 = 5; -pub const SQLITE_TEXT: i32 = 3; -pub const SQLITE3_TEXT: i32 = 3; -pub const SQLITE_UTF8: i32 = 1; -pub const SQLITE_UTF16LE: i32 = 2; -pub const SQLITE_UTF16BE: i32 = 3; -pub const SQLITE_UTF16: i32 = 4; -pub const SQLITE_ANY: i32 = 5; -pub const SQLITE_UTF16_ALIGNED: i32 = 8; -pub const SQLITE_DETERMINISTIC: i32 = 2048; -pub const SQLITE_WIN32_DATA_DIRECTORY_TYPE: i32 = 1; -pub const SQLITE_WIN32_TEMP_DIRECTORY_TYPE: i32 = 2; -pub const SQLITE_INDEX_SCAN_UNIQUE: i32 = 1; -pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; -pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; -pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; -pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; -pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; -pub const SQLITE_INDEX_CONSTRAINT_LIKE: i32 = 65; -pub const SQLITE_INDEX_CONSTRAINT_GLOB: i32 = 66; -pub const SQLITE_INDEX_CONSTRAINT_REGEXP: i32 = 67; -pub const SQLITE_INDEX_CONSTRAINT_NE: i32 = 68; -pub const SQLITE_INDEX_CONSTRAINT_ISNOT: i32 = 69; -pub const SQLITE_INDEX_CONSTRAINT_ISNOTNULL: i32 = 70; -pub const SQLITE_INDEX_CONSTRAINT_ISNULL: i32 = 71; -pub const SQLITE_INDEX_CONSTRAINT_IS: i32 = 72; -pub const SQLITE_INDEX_CONSTRAINT_FUNCTION: i32 = 150; -pub const SQLITE_MUTEX_FAST: i32 = 0; -pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; -pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; -pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; -pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; -pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; -pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; -pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; -pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; -pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; -pub const SQLITE_MUTEX_STATIC_APP1: i32 = 8; -pub const SQLITE_MUTEX_STATIC_APP2: i32 = 9; -pub const SQLITE_MUTEX_STATIC_APP3: i32 = 10; -pub const SQLITE_MUTEX_STATIC_VFS1: i32 = 11; -pub const SQLITE_MUTEX_STATIC_VFS2: i32 = 12; -pub const SQLITE_MUTEX_STATIC_VFS3: i32 = 13; -pub const SQLITE_TESTCTRL_FIRST: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; -pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; -pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; -pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; -pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; -pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; -pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; -pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; -pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; -pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; -pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; -pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 17; -pub const SQLITE_TESTCTRL_INTERNAL_FUNCTIONS: i32 = 17; -pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 18; -pub const SQLITE_TESTCTRL_EXPLAIN_STMT: i32 = 19; -pub const SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD: i32 = 19; -pub const SQLITE_TESTCTRL_NEVER_CORRUPT: i32 = 20; -pub const SQLITE_TESTCTRL_VDBE_COVERAGE: i32 = 21; -pub const SQLITE_TESTCTRL_BYTEORDER: i32 = 22; -pub const SQLITE_TESTCTRL_ISINIT: i32 = 23; -pub const SQLITE_TESTCTRL_SORTER_MMAP: i32 = 24; -pub const SQLITE_TESTCTRL_IMPOSTER: i32 = 25; -pub const SQLITE_TESTCTRL_PARSER_COVERAGE: i32 = 26; -pub const SQLITE_TESTCTRL_LAST: i32 = 26; -pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; -pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; -pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; -pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; -pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; -pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; -pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; -pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; -pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; -pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; -pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; -pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; -pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; -pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; -pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; -pub const SQLITE_DBSTATUS_CACHE_HIT: i32 = 7; -pub const SQLITE_DBSTATUS_CACHE_MISS: i32 = 8; -pub const SQLITE_DBSTATUS_CACHE_WRITE: i32 = 9; -pub const SQLITE_DBSTATUS_DEFERRED_FKS: i32 = 10; -pub const SQLITE_DBSTATUS_CACHE_USED_SHARED: i32 = 11; -pub const SQLITE_DBSTATUS_CACHE_SPILL: i32 = 12; -pub const SQLITE_DBSTATUS_MAX: i32 = 12; -pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; -pub const SQLITE_STMTSTATUS_SORT: i32 = 2; -pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; -pub const SQLITE_STMTSTATUS_VM_STEP: i32 = 4; -pub const SQLITE_STMTSTATUS_REPREPARE: i32 = 5; -pub const SQLITE_STMTSTATUS_RUN: i32 = 6; -pub const SQLITE_STMTSTATUS_MEMUSED: i32 = 99; -pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; -pub const SQLITE_CHECKPOINT_FULL: i32 = 1; -pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; -pub const SQLITE_CHECKPOINT_TRUNCATE: i32 = 3; -pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; -pub const SQLITE_ROLLBACK: i32 = 1; -pub const SQLITE_FAIL: i32 = 3; -pub const SQLITE_REPLACE: i32 = 5; -pub const SQLITE_SCANSTAT_NLOOP: i32 = 0; -pub const SQLITE_SCANSTAT_NVISIT: i32 = 1; -pub const SQLITE_SCANSTAT_EST: i32 = 2; -pub const SQLITE_SCANSTAT_NAME: i32 = 3; -pub const SQLITE_SCANSTAT_EXPLAIN: i32 = 4; -pub const SQLITE_SCANSTAT_SELECTID: i32 = 5; -pub const SQLITE_SERIALIZE_NOCOPY: i32 = 1; -pub const SQLITE_DESERIALIZE_FREEONCLOSE: i32 = 1; -pub const SQLITE_DESERIALIZE_RESIZEABLE: i32 = 2; -pub const SQLITE_DESERIALIZE_READONLY: i32 = 4; -pub const NOT_WITHIN: i32 = 0; -pub const PARTLY_WITHIN: i32 = 1; -pub const FULLY_WITHIN: i32 = 2; -pub const FTS5_TOKENIZE_QUERY: i32 = 1; -pub const FTS5_TOKENIZE_PREFIX: i32 = 2; -pub const FTS5_TOKENIZE_DOCUMENT: i32 = 4; -pub const FTS5_TOKENIZE_AUX: i32 = 8; -pub const FTS5_TOKEN_COLOCATED: i32 = 1; -pub type va_list = __builtin_va_list; -pub type __gnuc_va_list = __builtin_va_list; -extern "C" { - #[link_name = "\u{1}sqlite3_version"] - pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; -} -extern "C" { - pub fn sqlite3_libversion() -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_sourceid() -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_libversion_number() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_compileoption_used( - zOptName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_compileoption_get(N: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_threadsafe() -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3 { - _unused: [u8; 0], -} -pub type sqlite_int64 = ::std::os::raw::c_longlong; -pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; -pub type sqlite3_int64 = sqlite_int64; -pub type sqlite3_uint64 = sqlite_uint64; -extern "C" { - pub fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -pub type sqlite3_callback = ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, ->; -extern "C" { - pub fn sqlite3_exec( - arg1: *mut sqlite3, - sql: *const ::std::os::raw::c_char, - callback: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg2: *mut ::std::os::raw::c_void, - errmsg: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_file { - pub pMethods: *const sqlite3_io_methods, -} -#[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_file)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_file)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_file), - "::", - stringify!(pMethods) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_io_methods { - pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xRead: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *mut ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xWrite: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *const ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pSize: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xUnlock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCheckReservedLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileControl: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - op: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xSectorSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xDeviceCharacteristics: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xShmMap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iPg: ::std::os::raw::c_int, - pgsz: ::std::os::raw::c_int, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xShmLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - offset: ::std::os::raw::c_int, - n: ::std::os::raw::c_int, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xShmBarrier: ::std::option::Option, - pub xShmUnmap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - deleteFlag: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iOfst: sqlite3_int64, - iAmt: ::std::os::raw::c_int, - pp: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xUnfetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iOfst: sqlite3_int64, - p: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_io_methods() { - assert_eq!( - ::std::mem::size_of::(), - 152usize, - concat!("Size of: ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xRead) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xWrite) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnlock) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xCheckReservedLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileControl) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSectorSize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ - as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xDeviceCharacteristics) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmMap) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmBarrier) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmUnmap) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnfetch as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnfetch) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_api_routines { - _unused: [u8; 0], -} -pub type sqlite3_syscall_ptr = ::std::option::Option; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vfs { - pub iVersion: ::std::os::raw::c_int, - pub szOsFile: ::std::os::raw::c_int, - pub mxPathname: ::std::os::raw::c_int, - pub pNext: *mut sqlite3_vfs, - pub zName: *const ::std::os::raw::c_char, - pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - pOutFlags: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - syncDir: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xAccess: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - flags: ::std::os::raw::c_int, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFullPathname: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - nOut: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xDlOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zFilename: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void, - >, - pub xDlError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zErrMsg: *mut ::std::os::raw::c_char, - ), - >, - pub xDlSym: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ) -> ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ), - >, - >, - pub xDlClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), - >, - pub xRandomness: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSleep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - microseconds: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTime: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, - >, - pub xGetLastError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTimeInt64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xSetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: sqlite3_syscall_ptr, - ) -> ::std::os::raw::c_int, - >, - pub xGetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> sqlite3_syscall_ptr, - >, - pub xNextSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!( - ::std::mem::size_of::(), - 168usize, - concat!("Size of: ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(szOsFile) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(mxPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(zName) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pAppData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xAccess) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xFullPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlSym) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xRandomness) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSleep) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTime) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetLastError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTimeInt64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xNextSystemCall) - ) - ); -} -extern "C" { - pub fn sqlite3_initialize() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_shutdown() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_os_init() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_os_end() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_db_config( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xRoundup: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub pAppData: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!( - ::std::mem::size_of::(), - 64usize, - concat!("Size of: ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xMalloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xFree) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRealloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRoundup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(pAppData) - ) - ); -} -extern "C" { - pub fn sqlite3_extended_result_codes( - arg1: *mut sqlite3, - onoff: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_set_last_insert_rowid(arg1: *mut sqlite3, arg2: sqlite3_int64); -} -extern "C" { - pub fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_interrupt(arg1: *mut sqlite3); -} -extern "C" { - pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_busy_handler( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_busy_timeout( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_get_table( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - pazResult: *mut *mut *mut ::std::os::raw::c_char, - pnRow: *mut ::std::os::raw::c_int, - pnColumn: *mut ::std::os::raw::c_int, - pzErrmsg: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char); -} -extern "C" { - pub fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char, ...) - -> *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_vmprintf( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_snprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_vsnprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_malloc64(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_realloc( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_realloc64( - arg1: *mut ::std::os::raw::c_void, - arg2: sqlite3_uint64, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_free(arg1: *mut ::std::os::raw::c_void); -} -extern "C" { - pub fn sqlite3_msize(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64; -} -extern "C" { - pub fn sqlite3_memory_used() -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_randomness(N: ::std::os::raw::c_int, P: *mut ::std::os::raw::c_void); -} -extern "C" { - pub fn sqlite3_set_authorizer( - arg1: *mut sqlite3, - xAuth: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pUserData: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_trace( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_profile( - arg1: *mut sqlite3, - xProfile: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_uint64, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_trace_v2( - arg1: *mut sqlite3, - uMask: ::std::os::raw::c_uint, - xCallback: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_uint, - arg2: *mut ::std::os::raw::c_void, - arg3: *mut ::std::os::raw::c_void, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pCtx: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_progress_handler( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, - ); -} -extern "C" { - pub fn sqlite3_open( - filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_open16( - filename: *const ::std::os::raw::c_void, - ppDb: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_open_v2( - filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3, - flags: ::std::os::raw::c_int, - zVfs: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_uri_parameter( - zFilename: *const ::std::os::raw::c_char, - zParam: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_uri_boolean( - zFile: *const ::std::os::raw::c_char, - zParam: *const ::std::os::raw::c_char, - bDefault: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_uri_int64( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_int64, - ) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_extended_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt { - _unused: [u8; 0], -} -extern "C" { - pub fn sqlite3_limit( - arg1: *mut sqlite3, - id: ::std::os::raw::c_int, - newVal: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_prepare( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_prepare_v2( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_prepare_v3( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - prepFlags: ::std::os::raw::c_uint, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_prepare16( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_prepare16_v2( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_prepare16_v3( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - prepFlags: ::std::os::raw::c_uint, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_expanded_sql(pStmt: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_normalized_sql(pStmt: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_stmt_readonly(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_value { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_context { - _unused: [u8; 0], -} -extern "C" { - pub fn sqlite3_bind_blob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_blob64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_double( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_int( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_int64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_int64, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_null( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_text( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_text16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_text64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - encoding: ::std::os::raw::c_uchar, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_value( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_pointer( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: *const ::std::os::raw::c_char, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_zeroblob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - n: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_zeroblob64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_uint64, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_parameter_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_bind_parameter_index( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_name( - arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_column_name16( - arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_database_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_column_database_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_table_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_column_table_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_origin_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_column_origin_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_decltype( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_column_decltype16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_blob( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64; -} -extern "C" { - pub fn sqlite3_column_int( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_int64( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_column_text( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_uchar; -} -extern "C" { - pub fn sqlite3_column_text16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_value( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *mut sqlite3_value; -} -extern "C" { - pub fn sqlite3_column_bytes( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_bytes16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_type( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function( - db: *mut sqlite3, - zFunctionName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function16( - db: *mut sqlite3, - zFunctionName: *const ::std::os::raw::c_void, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function_v2( - db: *mut sqlite3, - zFunctionName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_window_function( - db: *mut sqlite3, - zFunctionName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xValue: ::std::option::Option, - xInverse: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_transfer_bindings( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_global_recover() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_thread_cleanup(); -} -extern "C" { - pub fn sqlite3_memory_alarm( - arg1: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: sqlite3_int64, - arg3: ::std::os::raw::c_int, - ), - >, - arg2: *mut ::std::os::raw::c_void, - arg3: sqlite3_int64, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64; -} -extern "C" { - pub fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_value_pointer( - arg1: *mut sqlite3_value, - arg2: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar; -} -extern "C" { - pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_nochange(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_subtype(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint; -} -extern "C" { - pub fn sqlite3_value_dup(arg1: *const sqlite3_value) -> *mut sqlite3_value; -} -extern "C" { - pub fn sqlite3_value_free(arg1: *mut sqlite3_value); -} -extern "C" { - pub fn sqlite3_aggregate_context( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3; -} -extern "C" { - pub fn sqlite3_get_auxdata( - arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_set_auxdata( - arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option, - ); -} -pub type sqlite3_destructor_type = - ::std::option::Option; -extern "C" { - pub fn sqlite3_result_blob( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_blob64( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64); -} -extern "C" { - pub fn sqlite3_result_error( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ); -} -extern "C" { - pub fn sqlite3_result_error16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - ); -} -extern "C" { - pub fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context); -} -extern "C" { - pub fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context); -} -extern "C" { - pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite3_int64); -} -extern "C" { - pub fn sqlite3_result_null(arg1: *mut sqlite3_context); -} -extern "C" { - pub fn sqlite3_result_text( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_text64( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - encoding: ::std::os::raw::c_uchar, - ); -} -extern "C" { - pub fn sqlite3_result_text16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_text16le( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_text16be( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value); -} -extern "C" { - pub fn sqlite3_result_pointer( - arg1: *mut sqlite3_context, - arg2: *mut ::std::os::raw::c_void, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, n: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_result_zeroblob64( - arg1: *mut sqlite3_context, - n: sqlite3_uint64, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_result_subtype(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint); -} -extern "C" { - pub fn sqlite3_create_collation( - arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - xCompare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation_v2( - arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - xCompare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation16( - arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_void, - eTextRep: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - xCompare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed16( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; -} -extern "C" { - #[link_name = "\u{1}sqlite3_temp_directory"] - pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; -} -extern "C" { - #[link_name = "\u{1}sqlite3_data_directory"] - pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_win32_set_directory( - type_: ::std::os::raw::c_ulong, - zValue: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_win32_set_directory8( - type_: ::std::os::raw::c_ulong, - zValue: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_win32_set_directory16( - type_: ::std::os::raw::c_ulong, - zValue: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3; -} -extern "C" { - pub fn sqlite3_db_filename( - db: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_db_readonly( - db: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) -> *mut sqlite3_stmt; -} -extern "C" { - pub fn sqlite3_commit_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_rollback_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_update_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_soft_heap_limit64(N: sqlite3_int64) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_soft_heap_limit(N: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_table_column_metadata( - db: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - zTableName: *const ::std::os::raw::c_char, - zColumnName: *const ::std::os::raw::c_char, - pzDataType: *mut *const ::std::os::raw::c_char, - pzCollSeq: *mut *const ::std::os::raw::c_char, - pNotNull: *mut ::std::os::raw::c_int, - pPrimaryKey: *mut ::std::os::raw::c_int, - pAutoinc: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_load_extension( - db: *mut sqlite3, - zFile: *const ::std::os::raw::c_char, - zProc: *const ::std::os::raw::c_char, - pzErrMsg: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_enable_load_extension( - db: *mut sqlite3, - onoff: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_auto_extension( - xEntryPoint: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_cancel_auto_extension( - xEntryPoint: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_reset_auto_extension(); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xConnect: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xBestIndex: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: *mut sqlite3_index_info, - ) -> ::std::os::raw::c_int, - >, - pub xDisconnect: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xDestroy: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - ppCursor: *mut *mut sqlite3_vtab_cursor, - ) -> ::std::os::raw::c_int, - >, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xFilter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - idxNum: ::std::os::raw::c_int, - idxStr: *const ::std::os::raw::c_char, - argc: ::std::os::raw::c_int, - argv: *mut *mut sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub xNext: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xEof: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - arg2: *mut sqlite3_context, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - pRowid: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xUpdate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - arg4: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xBegin: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xCommit: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xRollback: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xFindFunction: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - nArg: ::std::os::raw::c_int, - zName: *const ::std::os::raw::c_char, - pxFunc: *mut ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - ppArg: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xRename: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - zNew: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSavepoint: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRelease: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRollbackTo: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xShadowName: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!( - ::std::mem::size_of::(), - 192usize, - concat!("Size of: ", stringify!(sqlite3_module)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_module)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xConnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBestIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDisconnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFilter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xEof) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xColumn) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xUpdate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBegin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCommit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollback) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFindFunction) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRename) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSavepoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRelease) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollbackTo) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShadowName as *const _ as usize }, - 184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xShadowName) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info { - pub nConstraint: ::std::os::raw::c_int, - pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, - pub nOrderBy: ::std::os::raw::c_int, - pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, - pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, - pub idxNum: ::std::os::raw::c_int, - pub idxStr: *mut ::std::os::raw::c_char, - pub needToFreeIdxStr: ::std::os::raw::c_int, - pub orderByConsumed: ::std::os::raw::c_int, - pub estimatedCost: f64, - pub estimatedRows: sqlite3_int64, - pub idxFlags: ::std::os::raw::c_int, - pub colUsed: sqlite3_uint64, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint { - pub iColumn: ::std::os::raw::c_int, - pub op: ::std::os::raw::c_uchar, - pub usable: ::std::os::raw::c_uchar, - pub iTermOffset: ::std::os::raw::c_int, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).op as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(op) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).usable - as *const _ as usize - }, - 5usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(usable) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iTermOffset - as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iTermOffset) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_orderby { - pub iColumn: ::std::os::raw::c_int, - pub desc: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).desc as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(desc) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint_usage { - pub argvIndex: ::std::os::raw::c_int, - pub omit: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).argvIndex - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(argvIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).omit - as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(omit) - ) - ); -} -#[test] -fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!( - ::std::mem::size_of::(), - 96usize, - concat!("Size of: ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nOrderBy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aOrderBy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraintUsage) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxNum) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(needToFreeIdxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(orderByConsumed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedCost as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedCost) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedRows as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedRows) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxFlags as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxFlags) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).colUsed as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(colUsed) - ) - ); -} -extern "C" { - pub fn sqlite3_create_module( - db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - p: *const sqlite3_module, - pClientData: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_module_v2( - db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - p: *const sqlite3_module, - pClientData: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(pModule) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(nRef) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(zErrMsg) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab_cursor { - pub pVtab: *mut sqlite3_vtab, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab_cursor), - "::", - stringify!(pVtab) - ) - ); -} -extern "C" { - pub fn sqlite3_declare_vtab( - arg1: *mut sqlite3, - zSQL: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_overload_function( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob { - _unused: [u8; 0], -} -extern "C" { - pub fn sqlite3_blob_open( - arg1: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - zTable: *const ::std::os::raw::c_char, - zColumn: *const ::std::os::raw::c_char, - iRow: sqlite3_int64, - flags: ::std::os::raw::c_int, - ppBlob: *mut *mut sqlite3_blob, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_blob_reopen( - arg1: *mut sqlite3_blob, - arg2: sqlite3_int64, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_blob_read( - arg1: *mut sqlite3_blob, - Z: *mut ::std::os::raw::c_void, - N: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_blob_write( - arg1: *mut sqlite3_blob, - z: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs; -} -extern "C" { - pub fn sqlite3_vfs_register( - arg1: *mut sqlite3_vfs, - makeDflt: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex; -} -extern "C" { - pub fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex); -} -extern "C" { - pub fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex); -} -extern "C" { - pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexNotheld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexInit as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnd) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexAlloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexFree as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexFree) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexTry) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexLeave) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexHeld) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexNotheld) - ) - ); -} -extern "C" { - pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex; -} -extern "C" { - pub fn sqlite3_file_control( - arg1: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - op: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_keyword_count() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_keyword_name( - arg1: ::std::os::raw::c_int, - arg2: *mut *const ::std::os::raw::c_char, - arg3: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_keyword_check( - arg1: *const ::std::os::raw::c_char, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_str { - _unused: [u8; 0], -} -extern "C" { - pub fn sqlite3_str_new(arg1: *mut sqlite3) -> *mut sqlite3_str; -} -extern "C" { - pub fn sqlite3_str_finish(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_str_appendf(arg1: *mut sqlite3_str, zFormat: *const ::std::os::raw::c_char, ...); -} -extern "C" { - pub fn sqlite3_str_vappendf( - arg1: *mut sqlite3_str, - zFormat: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, - ); -} -extern "C" { - pub fn sqlite3_str_append( - arg1: *mut sqlite3_str, - zIn: *const ::std::os::raw::c_char, - N: ::std::os::raw::c_int, - ); -} -extern "C" { - pub fn sqlite3_str_appendall(arg1: *mut sqlite3_str, zIn: *const ::std::os::raw::c_char); -} -extern "C" { - pub fn sqlite3_str_appendchar( - arg1: *mut sqlite3_str, - N: ::std::os::raw::c_int, - C: ::std::os::raw::c_char, - ); -} -extern "C" { - pub fn sqlite3_str_reset(arg1: *mut sqlite3_str); -} -extern "C" { - pub fn sqlite3_str_errcode(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_str_length(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_str_value(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_status( - op: ::std::os::raw::c_int, - pCurrent: *mut ::std::os::raw::c_int, - pHighwater: *mut ::std::os::raw::c_int, - resetFlag: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_status64( - op: ::std::os::raw::c_int, - pCurrent: *mut sqlite3_int64, - pHighwater: *mut sqlite3_int64, - resetFlag: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_db_status( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - pCur: *mut ::std::os::raw::c_int, - pHiwtr: *mut ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_stmt_status( - arg1: *mut sqlite3_stmt, - op: ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_page { - pub pBuf: *mut ::std::os::raw::c_void, - pub pExtra: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_page() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(sqlite3_pcache_page)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_page)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_page), - "::", - stringify!(pBuf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_page), - "::", - stringify!(pExtra) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods2 { - pub iVersion: ::std::os::raw::c_int, - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - szExtra: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache_page, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut sqlite3_pcache_page, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut sqlite3_pcache_page, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, - pub xShrink: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods2() { - assert_eq!( - ::std::mem::size_of::(), - 104usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iVersion as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDestroy as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xShrink) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods { - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!( - ::std::mem::size_of::(), - 88usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xDestroy) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_backup { - _unused: [u8; 0], -} -extern "C" { - pub fn sqlite3_backup_init( - pDest: *mut sqlite3, - zDestName: *const ::std::os::raw::c_char, - pSource: *mut sqlite3, - zSourceName: *const ::std::os::raw::c_char, - ) -> *mut sqlite3_backup; -} -extern "C" { - pub fn sqlite3_backup_step( - p: *mut sqlite3_backup, - nPage: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_backup_finish(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_backup_remaining(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_backup_pagecount(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_unlock_notify( - pBlocked: *mut sqlite3, - xNotify: ::std::option::Option< - unsafe extern "C" fn( - apArg: *mut *mut ::std::os::raw::c_void, - nArg: ::std::os::raw::c_int, - ), - >, - pNotifyArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_stricmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_strnicmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_strglob( - zGlob: *const ::std::os::raw::c_char, - zStr: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_strlike( - zGlob: *const ::std::os::raw::c_char, - zStr: *const ::std::os::raw::c_char, - cEsc: ::std::os::raw::c_uint, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_log( - iErrCode: ::std::os::raw::c_int, - zFormat: *const ::std::os::raw::c_char, - ... - ); -} -extern "C" { - pub fn sqlite3_wal_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_wal_autocheckpoint( - db: *mut sqlite3, - N: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_wal_checkpoint( - db: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_wal_checkpoint_v2( - db: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - eMode: ::std::os::raw::c_int, - pnLog: *mut ::std::os::raw::c_int, - pnCkpt: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_vtab_config( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_vtab_nochange(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_vtab_collation( - arg1: *mut sqlite3_index_info, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_stmt_scanstatus( - pStmt: *mut sqlite3_stmt, - idx: ::std::os::raw::c_int, - iScanStatusOp: ::std::os::raw::c_int, - pOut: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_stmt_scanstatus_reset(arg1: *mut sqlite3_stmt); -} -extern "C" { - pub fn sqlite3_db_cacheflush(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_system_errno(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct sqlite3_snapshot { - pub hidden: [::std::os::raw::c_uchar; 48usize], -} -#[test] -fn bindgen_test_layout_sqlite3_snapshot() { - assert_eq!( - ::std::mem::size_of::(), - 48usize, - concat!("Size of: ", stringify!(sqlite3_snapshot)) - ); - assert_eq!( - ::std::mem::align_of::(), - 1usize, - concat!("Alignment of ", stringify!(sqlite3_snapshot)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).hidden as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_snapshot), - "::", - stringify!(hidden) - ) - ); -} -extern "C" { - pub fn sqlite3_snapshot_get( - db: *mut sqlite3, - zSchema: *const ::std::os::raw::c_char, - ppSnapshot: *mut *mut sqlite3_snapshot, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_snapshot_open( - db: *mut sqlite3, - zSchema: *const ::std::os::raw::c_char, - pSnapshot: *mut sqlite3_snapshot, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_snapshot_free(arg1: *mut sqlite3_snapshot); -} -extern "C" { - pub fn sqlite3_snapshot_cmp( - p1: *mut sqlite3_snapshot, - p2: *mut sqlite3_snapshot, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_snapshot_recover( - db: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_serialize( - db: *mut sqlite3, - zSchema: *const ::std::os::raw::c_char, - piSize: *mut sqlite3_int64, - mFlags: ::std::os::raw::c_uint, - ) -> *mut ::std::os::raw::c_uchar; -} -extern "C" { - pub fn sqlite3_deserialize( - db: *mut sqlite3, - zSchema: *const ::std::os::raw::c_char, - pData: *mut ::std::os::raw::c_uchar, - szDb: sqlite3_int64, - szBuf: sqlite3_int64, - mFlags: ::std::os::raw::c_uint, - ) -> ::std::os::raw::c_int; -} -pub type sqlite3_rtree_dbl = f64; -extern "C" { - pub fn sqlite3_rtree_geometry_callback( - db: *mut sqlite3, - zGeom: *const ::std::os::raw::c_char, - xGeom: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_rtree_geometry, - arg2: ::std::os::raw::c_int, - arg3: *mut sqlite3_rtree_dbl, - arg4: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pContext: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_rtree_geometry { - pub pContext: *mut ::std::os::raw::c_void, - pub nParam: ::std::os::raw::c_int, - pub aParam: *mut sqlite3_rtree_dbl, - pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_rtree_geometry() { - assert_eq!( - ::std::mem::size_of::(), - 40usize, - concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pContext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(nParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(aParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pUser) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(xDelUser) - ) - ); -} -extern "C" { - pub fn sqlite3_rtree_query_callback( - db: *mut sqlite3, - zQueryFunc: *const ::std::os::raw::c_char, - xQueryFunc: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_rtree_query_info) -> ::std::os::raw::c_int, - >, - pContext: *mut ::std::os::raw::c_void, - xDestructor: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_rtree_query_info { - pub pContext: *mut ::std::os::raw::c_void, - pub nParam: ::std::os::raw::c_int, - pub aParam: *mut sqlite3_rtree_dbl, - pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, - pub aCoord: *mut sqlite3_rtree_dbl, - pub anQueue: *mut ::std::os::raw::c_uint, - pub nCoord: ::std::os::raw::c_int, - pub iLevel: ::std::os::raw::c_int, - pub mxLevel: ::std::os::raw::c_int, - pub iRowid: sqlite3_int64, - pub rParentScore: sqlite3_rtree_dbl, - pub eParentWithin: ::std::os::raw::c_int, - pub eWithin: ::std::os::raw::c_int, - pub rScore: sqlite3_rtree_dbl, - pub apSqlParam: *mut *mut sqlite3_value, -} -#[test] -fn bindgen_test_layout_sqlite3_rtree_query_info() { - assert_eq!( - ::std::mem::size_of::(), - 112usize, - concat!("Size of: ", stringify!(sqlite3_rtree_query_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_rtree_query_info)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).pContext as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(pContext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(nParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(aParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(pUser) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDelUser as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(xDelUser) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aCoord as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(aCoord) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).anQueue as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(anQueue) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nCoord as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(nCoord) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iLevel as *const _ as usize }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(iLevel) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mxLevel as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(mxLevel) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iRowid as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(iRowid) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rParentScore as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(rParentScore) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).eParentWithin as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(eParentWithin) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).eWithin as *const _ as usize - }, - 92usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(eWithin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).rScore as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(rScore) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).apSqlParam as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(apSqlParam) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5Context { - _unused: [u8; 0], -} -pub type fts5_extension_function = ::std::option::Option< - unsafe extern "C" fn( - pApi: *const Fts5ExtensionApi, - pFts: *mut Fts5Context, - pCtx: *mut sqlite3_context, - nVal: ::std::os::raw::c_int, - apVal: *mut *mut sqlite3_value, - ), ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5PhraseIter { - pub a: *const ::std::os::raw::c_uchar, - pub b: *const ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_Fts5PhraseIter() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(Fts5PhraseIter)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Fts5PhraseIter)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).a as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Fts5PhraseIter), - "::", - stringify!(a) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).b as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Fts5PhraseIter), - "::", - stringify!(b) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5ExtensionApi { - pub iVersion: ::std::os::raw::c_int, - pub xUserData: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> *mut ::std::os::raw::c_void, - >, - pub xColumnCount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, - >, - pub xRowCount: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pnRow: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xColumnTotalSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pnToken: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTokenize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pText: *const ::std::os::raw::c_char, - nText: ::std::os::raw::c_int, - pCtx: *mut ::std::os::raw::c_void, - xToken: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, - arg6: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseCount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, - >, - pub xPhraseSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xInstCount: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pnInst: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xInst: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iIdx: ::std::os::raw::c_int, - piPhrase: *mut ::std::os::raw::c_int, - piCol: *mut ::std::os::raw::c_int, - piOff: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: - ::std::option::Option sqlite3_int64>, - pub xColumnText: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pz: *mut *const ::std::os::raw::c_char, - pn: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xColumnSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pnToken: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xQueryPhrase: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - pUserData: *mut ::std::os::raw::c_void, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const Fts5ExtensionApi, - arg2: *mut Fts5Context, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub xSetAuxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pAux: *mut ::std::os::raw::c_void, - xDelete: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub xGetAuxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - bClear: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xPhraseFirst: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - arg2: *mut Fts5PhraseIter, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseNext: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - arg2: *mut Fts5PhraseIter, - piCol: *mut ::std::os::raw::c_int, - piOff: *mut ::std::os::raw::c_int, - ), - >, - pub xPhraseFirstColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - arg2: *mut Fts5PhraseIter, - arg3: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseNextColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - arg2: *mut Fts5PhraseIter, - piCol: *mut ::std::os::raw::c_int, - ), - >, -} -#[test] -fn bindgen_test_layout_Fts5ExtensionApi() { - assert_eq!( - ::std::mem::size_of::(), - 160usize, - concat!("Size of: ", stringify!(Fts5ExtensionApi)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Fts5ExtensionApi)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUserData as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xUserData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnCount as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowCount as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xRowCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xColumnTotalSize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnTotalSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xTokenize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseCount as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseSize as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInstCount as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xInstCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInst as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xInst) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnText as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnText) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnSize as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xQueryPhrase as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xQueryPhrase) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSetAuxdata as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xSetAuxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetAuxdata as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xGetAuxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseFirst as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseFirst) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseNext as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseNext) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPhraseFirstColumn as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseFirstColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPhraseNextColumn as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseNextColumn) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5Tokenizer { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct fts5_tokenizer { - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - azArg: *mut *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ppOut: *mut *mut Fts5Tokenizer, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option, - pub xTokenize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Tokenizer, - pCtx: *mut ::std::os::raw::c_void, - flags: ::std::os::raw::c_int, - pText: *const ::std::os::raw::c_char, - nText: ::std::os::raw::c_int, - xToken: ::std::option::Option< - unsafe extern "C" fn( - pCtx: *mut ::std::os::raw::c_void, - tflags: ::std::os::raw::c_int, - pToken: *const ::std::os::raw::c_char, - nToken: ::std::os::raw::c_int, - iStart: ::std::os::raw::c_int, - iEnd: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_fts5_tokenizer() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(fts5_tokenizer)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(fts5_tokenizer)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xTokenize) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct fts5_api { - pub iVersion: ::std::os::raw::c_int, - pub xCreateTokenizer: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - pContext: *mut ::std::os::raw::c_void, - pTokenizer: *mut fts5_tokenizer, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub xFindTokenizer: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - ppContext: *mut *mut ::std::os::raw::c_void, - pTokenizer: *mut fts5_tokenizer, - ) -> ::std::os::raw::c_int, - >, - pub xCreateFunction: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - pContext: *mut ::std::os::raw::c_void, - xFunction: fts5_extension_function, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_fts5_api() { - assert_eq!( - ::std::mem::size_of::(), - 32usize, - concat!("Size of: ", stringify!(fts5_api)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(fts5_api)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreateTokenizer as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xCreateTokenizer) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindTokenizer as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xFindTokenizer) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreateFunction as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xCreateFunction) - ) - ); -} -pub type __builtin_va_list = [__va_list_tag; 1usize]; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct __va_list_tag { - pub gp_offset: ::std::os::raw::c_uint, - pub fp_offset: ::std::os::raw::c_uint, - pub overflow_arg_area: *mut ::std::os::raw::c_void, - pub reg_save_area: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout___va_list_tag() { - assert_eq!( - ::std::mem::size_of::<__va_list_tag>(), - 24usize, - concat!("Size of: ", stringify!(__va_list_tag)) - ); - assert_eq!( - ::std::mem::align_of::<__va_list_tag>(), - 8usize, - concat!("Alignment of ", stringify!(__va_list_tag)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(gp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(fp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(overflow_arg_area) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(reg_save_area) - ) - ); -} diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index 9f1e51656..1e1ad24e7 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -393,7 +393,6 @@ mod build_loadable_extension { fn try_vcpkg() -> Option { None } - } #[cfg(not(feature = "buildtime_bindgen"))] @@ -411,12 +410,8 @@ mod bindings { "bindgen-bindings/bindgen_3.7.7", #[cfg(feature = "min_sqlite_version_3_7_16")] "bindgen-bindings/bindgen_3.7.16", - #[cfg(feature = "min_sqlite_version_3_13_0")] - "bindgen-bindings/bindgen_3.13.0", #[cfg(feature = "min_sqlite_version_3_20_0")] "bindgen-bindings/bindgen_3.20.0", - #[cfg(feature = "min_sqlite_version_3_26_0")] - "bindgen-bindings/bindgen_3.26.0", ]; pub fn write_to_out_dir(_header: HeaderLocation, out_path: &Path) { @@ -440,7 +435,6 @@ mod bindings { "" } } - } #[cfg(feature = "buildtime_bindgen")] @@ -539,9 +533,9 @@ mod bindings { #[cfg(feature = "loadable_extension_embedded")] { - // an embedded loadable extension is one in which the rust code will be linked in to - // external code that implements the loadable extension and exports the sqlite3_api - // interface as a symbol + // an embedded loadable extension is one in which the rust code will be linked + // in to external code that implements the loadable extension + // and exports the sqlite3_api interface as a symbol output.push_str( r#" diff --git a/src/inner_connection.rs b/src/inner_connection.rs index 9deb4e549..735402bab 100644 --- a/src/inner_connection.rs +++ b/src/inner_connection.rs @@ -363,21 +363,34 @@ rusqlite was built against SQLite {} but the runtime SQLite version is {}. To fi }); } -#[cfg(not(any(feature = "loadable_extension", feature = "loadable_extension_embedded", feature= "non_threadsafe")))] +#[cfg(not(any( + feature = "loadable_extension", + feature = "loadable_extension_embedded", + feature = "non_threadsafe" +)))] static SQLITE_INIT: Once = Once::new(); pub static BYPASS_SQLITE_INIT: AtomicBool = AtomicBool::new(false); // threading mode checks are not possible when built as a loadable extension // since the sqlite3_threadsafe, sqlite3_config, and sqlite3_initialize // API calls are not available via the sqlite3_api_routines struct. -// They are also not available when sqlite is built without threadsafe (e.g. -DSQLITE_THREADSAFE=0) -// which is represented here by the "non_threadsafe" feature. -#[cfg(any(feature = "loadable_extension", feature = "loadable_extension_embedded", feature= "non_threadsafe"))] +// They are also not available when sqlite is built without threadsafe (e.g. +// -DSQLITE_THREADSAFE=0) which is represented here by the "non_threadsafe" +// feature. +#[cfg(any( + feature = "loadable_extension", + feature = "loadable_extension_embedded", + feature = "non_threadsafe" +))] fn ensure_safe_sqlite_threading_mode() -> Result<()> { Ok(()) } -#[cfg(not(any(feature = "loadable_extension", feature = "loadable_extension_embedded", feature= "non_threadsafe")))] +#[cfg(not(any( + feature = "loadable_extension", + feature = "loadable_extension_embedded", + feature = "non_threadsafe" +)))] fn ensure_safe_sqlite_threading_mode() -> Result<()> { // Ensure SQLite was compiled in thredsafe mode. if unsafe { ffi::sqlite3_threadsafe() == 0 } { diff --git a/src/lib.rs b/src/lib.rs index f6de6dc21..bcd27fa96 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -843,8 +843,13 @@ impl InterruptHandle { pub fn interrupt(&self) { let db_handle = self.db_lock.lock().unwrap(); if !db_handle.is_null() { - #[cfg(not(any(feature = "loadable_extension", feature = "loadable_extension_embedded")))] // no sqlite3_interrupt in a loadable extension - unsafe { ffi::sqlite3_interrupt(*db_handle) } + #[cfg(not(any( + feature = "loadable_extension", + feature = "loadable_extension_embedded" + )))] // no sqlite3_interrupt in a loadable extension + unsafe { + ffi::sqlite3_interrupt(*db_handle) + } } } } From 26c9193fa3e2830292f0ec925aafd031795673b8 Mon Sep 17 00:00:00 2001 From: gwenn Date: Tue, 11 Feb 2020 20:11:06 +0100 Subject: [PATCH 06/61] Remove some more old bindgens --- Cargo.toml | 10 +- README.md | 3 +- libsqlite3-sys/Cargo.toml | 2 - libsqlite3-sys/bindgen-bindings/README.md | 3 - .../bindgen_3.6.23-ext-embed.rs | 6855 --------------- .../bindgen-bindings/bindgen_3.6.23-ext.rs | 6853 --------------- .../bindgen-bindings/bindgen_3.6.23.rs | 3103 ------- .../bindgen_3.7.7-ext-embed.rs | 7831 ----------------- .../bindgen-bindings/bindgen_3.7.7-ext.rs | 7829 ---------------- .../bindgen-bindings/bindgen_3.7.7.rs | 3509 -------- .../generate-bindgen-bindings.sh | 4 - libsqlite3-sys/build.rs | 4 - 12 files changed, 6 insertions(+), 36000 deletions(-) delete mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.6.23-ext-embed.rs delete mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.6.23-ext.rs delete mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.6.23.rs delete mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.7.7-ext-embed.rs delete mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.7.7-ext.rs delete mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.7.7.rs diff --git a/Cargo.toml b/Cargo.toml index 9b92f808c..b09202d18 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -25,14 +25,14 @@ members = ["libsqlite3-sys"] [features] load_extension = [] # hot-backup interface: 3.6.11 (2009-02-18) -backup = ["libsqlite3-sys/min_sqlite_version_3_6_23"] +backup = ["libsqlite3-sys/min_sqlite_version_3_7_16"] # sqlite3_blob_reopen: 3.7.4 -blob = ["libsqlite3-sys/min_sqlite_version_3_7_7"] +blob = ["libsqlite3-sys/min_sqlite_version_3_7_16"] collation = [] # sqlite3_create_function_v2: 3.7.3 (2010-10-08) -functions = ["libsqlite3-sys/min_sqlite_version_3_7_7"] +functions = ["libsqlite3-sys/min_sqlite_version_3_7_16"] # sqlite3_log: 3.6.23 (2010-03-09) -trace = ["libsqlite3-sys/min_sqlite_version_3_6_23"] +trace = ["libsqlite3-sys/min_sqlite_version_3_7_16"] bundled = ["libsqlite3-sys/bundled", "modern_sqlite"] buildtime_bindgen = ["libsqlite3-sys/buildtime_bindgen"] loadable_extension = ["libsqlite3-sys/loadable_extension"] @@ -44,7 +44,7 @@ i128_blob = ["byteorder"] sqlcipher = ["libsqlite3-sys/sqlcipher"] unlock_notify = ["libsqlite3-sys/unlock_notify"] # xSavepoint, xRelease and xRollbackTo: 3.7.7 (2011-06-23) -vtab = ["libsqlite3-sys/min_sqlite_version_3_7_7", "lazy_static"] +vtab = ["libsqlite3-sys/min_sqlite_version_3_7_16", "lazy_static"] # xShadowName: 3.26.0 vtab_v3 = ["vtab"] csvtab = ["csv", "vtab"] diff --git a/README.md b/README.md index 965a1d90b..46beffc39 100644 --- a/README.md +++ b/README.md @@ -157,8 +157,7 @@ minimum SQLite version that supports your chosen features. If you are using pregenerated bindings are chosen: * `min_sqlite_version_3_6_8` - SQLite 3.6.8 bindings (this is the default) -* `min_sqlite_version_3_6_23` - SQLite 3.6.23 bindings -* `min_sqlite_version_3_7_7` - SQLite 3.7.7 bindings +* `min_sqlite_version_3_7_16` - SQLite 3.7.16 bindings If you use the `bundled` feature, you will get pregenerated bindings for the bundled version of SQLite. If you need other specific pregenerated binding diff --git a/libsqlite3-sys/Cargo.toml b/libsqlite3-sys/Cargo.toml index 4638c80de..c2dc3b52b 100644 --- a/libsqlite3-sys/Cargo.toml +++ b/libsqlite3-sys/Cargo.toml @@ -20,8 +20,6 @@ loadable_extension = ["syn", "quote"] loadable_extension_embedded = ["loadable_extension"] sqlcipher = [] min_sqlite_version_3_6_8 = ["pkg-config", "vcpkg"] -min_sqlite_version_3_6_23 = ["pkg-config", "vcpkg"] -min_sqlite_version_3_7_7 = ["pkg-config", "vcpkg"] min_sqlite_version_3_7_16 = ["pkg-config", "vcpkg"] min_sqlite_version_3_20_0 = ["pkg-config", "vcpkg"] # Bundle only the bindings file. Note that this does nothing if diff --git a/libsqlite3-sys/bindgen-bindings/README.md b/libsqlite3-sys/bindgen-bindings/README.md index 0899504a3..dd5a28bfc 100644 --- a/libsqlite3-sys/bindgen-bindings/README.md +++ b/libsqlite3-sys/bindgen-bindings/README.md @@ -17,10 +17,7 @@ The script `generate-bindgen-bindings.sh` will attempt to rebuild all of the pre sqlite3 amalgamation source links --------------------------------- The location of the amalgamation sources used to build these are: - - [3.28.0](https://sqlite.org/2019/sqlite-amalgamation-3280000.zip) - [3.7.16](https://sqlite.org/2013/sqlite-amalgamation-3071600.zip) - - [3.7.7](https://sqlite.org/sqlite-amalgamation-3070700.zip) - - [3.6.23](https://sqlite.org/sqlite-amalgamation-3_6_23.zip) - [3.6.8](https://sqlite.org/sqlite-amalgamation-3_6_8.zip) diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23-ext-embed.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23-ext-embed.rs deleted file mode 100644 index 603d84d38..000000000 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23-ext-embed.rs +++ /dev/null @@ -1,6855 +0,0 @@ -/* automatically generated by rust-bindgen */ - -pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.6.23\0"; -pub const SQLITE_VERSION_NUMBER: i32 = 3006023; -pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = - b"2010-03-09 19:31:43 4ae453ea7be69018d8c16eb8dabe05617397dc4d\0"; -pub const SQLITE_OK: i32 = 0; -pub const SQLITE_ERROR: i32 = 1; -pub const SQLITE_INTERNAL: i32 = 2; -pub const SQLITE_PERM: i32 = 3; -pub const SQLITE_ABORT: i32 = 4; -pub const SQLITE_BUSY: i32 = 5; -pub const SQLITE_LOCKED: i32 = 6; -pub const SQLITE_NOMEM: i32 = 7; -pub const SQLITE_READONLY: i32 = 8; -pub const SQLITE_INTERRUPT: i32 = 9; -pub const SQLITE_IOERR: i32 = 10; -pub const SQLITE_CORRUPT: i32 = 11; -pub const SQLITE_NOTFOUND: i32 = 12; -pub const SQLITE_FULL: i32 = 13; -pub const SQLITE_CANTOPEN: i32 = 14; -pub const SQLITE_PROTOCOL: i32 = 15; -pub const SQLITE_EMPTY: i32 = 16; -pub const SQLITE_SCHEMA: i32 = 17; -pub const SQLITE_TOOBIG: i32 = 18; -pub const SQLITE_CONSTRAINT: i32 = 19; -pub const SQLITE_MISMATCH: i32 = 20; -pub const SQLITE_MISUSE: i32 = 21; -pub const SQLITE_NOLFS: i32 = 22; -pub const SQLITE_AUTH: i32 = 23; -pub const SQLITE_FORMAT: i32 = 24; -pub const SQLITE_RANGE: i32 = 25; -pub const SQLITE_NOTADB: i32 = 26; -pub const SQLITE_ROW: i32 = 100; -pub const SQLITE_DONE: i32 = 101; -pub const SQLITE_IOERR_READ: i32 = 266; -pub const SQLITE_IOERR_SHORT_READ: i32 = 522; -pub const SQLITE_IOERR_WRITE: i32 = 778; -pub const SQLITE_IOERR_FSYNC: i32 = 1034; -pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; -pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; -pub const SQLITE_IOERR_FSTAT: i32 = 1802; -pub const SQLITE_IOERR_UNLOCK: i32 = 2058; -pub const SQLITE_IOERR_RDLOCK: i32 = 2314; -pub const SQLITE_IOERR_DELETE: i32 = 2570; -pub const SQLITE_IOERR_BLOCKED: i32 = 2826; -pub const SQLITE_IOERR_NOMEM: i32 = 3082; -pub const SQLITE_IOERR_ACCESS: i32 = 3338; -pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; -pub const SQLITE_IOERR_LOCK: i32 = 3850; -pub const SQLITE_IOERR_CLOSE: i32 = 4106; -pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; -pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; -pub const SQLITE_OPEN_READONLY: i32 = 1; -pub const SQLITE_OPEN_READWRITE: i32 = 2; -pub const SQLITE_OPEN_CREATE: i32 = 4; -pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; -pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; -pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; -pub const SQLITE_OPEN_MAIN_DB: i32 = 256; -pub const SQLITE_OPEN_TEMP_DB: i32 = 512; -pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; -pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; -pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; -pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; -pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; -pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; -pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; -pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; -pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; -pub const SQLITE_IOCAP_ATOMIC: i32 = 1; -pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; -pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; -pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; -pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; -pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; -pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; -pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; -pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; -pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; -pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; -pub const SQLITE_LOCK_NONE: i32 = 0; -pub const SQLITE_LOCK_SHARED: i32 = 1; -pub const SQLITE_LOCK_RESERVED: i32 = 2; -pub const SQLITE_LOCK_PENDING: i32 = 3; -pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; -pub const SQLITE_SYNC_NORMAL: i32 = 2; -pub const SQLITE_SYNC_FULL: i32 = 3; -pub const SQLITE_SYNC_DATAONLY: i32 = 16; -pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; -pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_LAST_ERRNO: i32 = 4; -pub const SQLITE_ACCESS_EXISTS: i32 = 0; -pub const SQLITE_ACCESS_READWRITE: i32 = 1; -pub const SQLITE_ACCESS_READ: i32 = 2; -pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; -pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; -pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; -pub const SQLITE_CONFIG_MALLOC: i32 = 4; -pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; -pub const SQLITE_CONFIG_SCRATCH: i32 = 6; -pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; -pub const SQLITE_CONFIG_HEAP: i32 = 8; -pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; -pub const SQLITE_CONFIG_MUTEX: i32 = 10; -pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; -pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; -pub const SQLITE_CONFIG_PCACHE: i32 = 14; -pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; -pub const SQLITE_CONFIG_LOG: i32 = 16; -pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; -pub const SQLITE_DENY: i32 = 1; -pub const SQLITE_IGNORE: i32 = 2; -pub const SQLITE_CREATE_INDEX: i32 = 1; -pub const SQLITE_CREATE_TABLE: i32 = 2; -pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; -pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; -pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; -pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; -pub const SQLITE_CREATE_TRIGGER: i32 = 7; -pub const SQLITE_CREATE_VIEW: i32 = 8; -pub const SQLITE_DELETE: i32 = 9; -pub const SQLITE_DROP_INDEX: i32 = 10; -pub const SQLITE_DROP_TABLE: i32 = 11; -pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; -pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; -pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; -pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; -pub const SQLITE_DROP_TRIGGER: i32 = 16; -pub const SQLITE_DROP_VIEW: i32 = 17; -pub const SQLITE_INSERT: i32 = 18; -pub const SQLITE_PRAGMA: i32 = 19; -pub const SQLITE_READ: i32 = 20; -pub const SQLITE_SELECT: i32 = 21; -pub const SQLITE_TRANSACTION: i32 = 22; -pub const SQLITE_UPDATE: i32 = 23; -pub const SQLITE_ATTACH: i32 = 24; -pub const SQLITE_DETACH: i32 = 25; -pub const SQLITE_ALTER_TABLE: i32 = 26; -pub const SQLITE_REINDEX: i32 = 27; -pub const SQLITE_ANALYZE: i32 = 28; -pub const SQLITE_CREATE_VTABLE: i32 = 29; -pub const SQLITE_DROP_VTABLE: i32 = 30; -pub const SQLITE_FUNCTION: i32 = 31; -pub const SQLITE_SAVEPOINT: i32 = 32; -pub const SQLITE_COPY: i32 = 0; -pub const SQLITE_LIMIT_LENGTH: i32 = 0; -pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; -pub const SQLITE_LIMIT_COLUMN: i32 = 2; -pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; -pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; -pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; -pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; -pub const SQLITE_LIMIT_ATTACHED: i32 = 7; -pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; -pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; -pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; -pub const SQLITE_INTEGER: i32 = 1; -pub const SQLITE_FLOAT: i32 = 2; -pub const SQLITE_BLOB: i32 = 4; -pub const SQLITE_NULL: i32 = 5; -pub const SQLITE_TEXT: i32 = 3; -pub const SQLITE3_TEXT: i32 = 3; -pub const SQLITE_UTF8: i32 = 1; -pub const SQLITE_UTF16LE: i32 = 2; -pub const SQLITE_UTF16BE: i32 = 3; -pub const SQLITE_UTF16: i32 = 4; -pub const SQLITE_ANY: i32 = 5; -pub const SQLITE_UTF16_ALIGNED: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; -pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; -pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; -pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; -pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; -pub const SQLITE_MUTEX_FAST: i32 = 0; -pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; -pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; -pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; -pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; -pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; -pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; -pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; -pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; -pub const SQLITE_TESTCTRL_FIRST: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; -pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; -pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; -pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; -pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; -pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; -pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; -pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; -pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; -pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; -pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; -pub const SQLITE_TESTCTRL_LAST: i32 = 16; -pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; -pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; -pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; -pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; -pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; -pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; -pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; -pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; -pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; -pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; -pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; -pub const SQLITE_STMTSTATUS_SORT: i32 = 2; -pub type va_list = __builtin_va_list; -pub type __gnuc_va_list = __builtin_va_list; -extern "C" { - #[link_name = "\u{1}sqlite3_version"] - pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3 { - _unused: [u8; 0], -} -pub type sqlite_int64 = ::std::os::raw::c_longlong; -pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; -pub type sqlite3_int64 = sqlite_int64; -pub type sqlite3_uint64 = sqlite_uint64; -pub type sqlite3_callback = ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_file { - pub pMethods: *const sqlite3_io_methods, -} -#[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_file)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_file)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_file), - "::", - stringify!(pMethods) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_io_methods { - pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xRead: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *mut ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xWrite: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *const ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pSize: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xUnlock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCheckReservedLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileControl: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - op: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xSectorSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xDeviceCharacteristics: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_io_methods() { - assert_eq!( - ::std::mem::size_of::(), - 104usize, - concat!("Size of: ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xRead) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xWrite) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnlock) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xCheckReservedLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileControl) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSectorSize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ - as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xDeviceCharacteristics) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vfs { - pub iVersion: ::std::os::raw::c_int, - pub szOsFile: ::std::os::raw::c_int, - pub mxPathname: ::std::os::raw::c_int, - pub pNext: *mut sqlite3_vfs, - pub zName: *const ::std::os::raw::c_char, - pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - pOutFlags: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - syncDir: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xAccess: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - flags: ::std::os::raw::c_int, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFullPathname: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - nOut: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xDlOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zFilename: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void, - >, - pub xDlError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zErrMsg: *mut ::std::os::raw::c_char, - ), - >, - pub xDlSym: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ) -> ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ), - >, - >, - pub xDlClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), - >, - pub xRandomness: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSleep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - microseconds: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTime: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, - >, - pub xGetLastError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!( - ::std::mem::size_of::(), - 136usize, - concat!("Size of: ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(szOsFile) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(mxPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(zName) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pAppData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xAccess) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xFullPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlSym) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xRandomness) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSleep) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTime) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetLastError) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xRoundup: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub pAppData: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!( - ::std::mem::size_of::(), - 64usize, - concat!("Size of: ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xMalloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xFree) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRealloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRoundup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(pAppData) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Mem { - _unused: [u8; 0], -} -pub type sqlite3_value = Mem; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_context { - _unused: [u8; 0], -} -pub type sqlite3_destructor_type = - ::std::option::Option; -extern "C" { - #[link_name = "\u{1}sqlite3_temp_directory"] - pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xConnect: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xBestIndex: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: *mut sqlite3_index_info, - ) -> ::std::os::raw::c_int, - >, - pub xDisconnect: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xDestroy: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - ppCursor: *mut *mut sqlite3_vtab_cursor, - ) -> ::std::os::raw::c_int, - >, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xFilter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - idxNum: ::std::os::raw::c_int, - idxStr: *const ::std::os::raw::c_char, - argc: ::std::os::raw::c_int, - argv: *mut *mut sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub xNext: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xEof: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - arg2: *mut sqlite3_context, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - pRowid: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xUpdate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - arg4: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xBegin: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xCommit: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xRollback: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xFindFunction: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - nArg: ::std::os::raw::c_int, - zName: *const ::std::os::raw::c_char, - pxFunc: *mut ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - ppArg: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xRename: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - zNew: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!( - ::std::mem::size_of::(), - 160usize, - concat!("Size of: ", stringify!(sqlite3_module)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_module)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xConnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBestIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDisconnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFilter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xEof) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xColumn) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xUpdate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBegin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCommit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollback) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFindFunction) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRename) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info { - pub nConstraint: ::std::os::raw::c_int, - pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, - pub nOrderBy: ::std::os::raw::c_int, - pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, - pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, - pub idxNum: ::std::os::raw::c_int, - pub idxStr: *mut ::std::os::raw::c_char, - pub needToFreeIdxStr: ::std::os::raw::c_int, - pub orderByConsumed: ::std::os::raw::c_int, - pub estimatedCost: f64, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint { - pub iColumn: ::std::os::raw::c_int, - pub op: ::std::os::raw::c_uchar, - pub usable: ::std::os::raw::c_uchar, - pub iTermOffset: ::std::os::raw::c_int, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).op as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(op) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).usable - as *const _ as usize - }, - 5usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(usable) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iTermOffset - as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iTermOffset) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_orderby { - pub iColumn: ::std::os::raw::c_int, - pub desc: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).desc as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(desc) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint_usage { - pub argvIndex: ::std::os::raw::c_int, - pub omit: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).argvIndex - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(argvIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).omit - as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(omit) - ) - ); -} -#[test] -fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nOrderBy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aOrderBy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraintUsage) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxNum) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(needToFreeIdxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(orderByConsumed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedCost as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedCost) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(pModule) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(nRef) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(zErrMsg) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab_cursor { - pub pVtab: *mut sqlite3_vtab, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab_cursor), - "::", - stringify!(pVtab) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexNotheld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexInit as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnd) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexAlloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexFree as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexFree) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexTry) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexLeave) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexHeld) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexNotheld) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods { - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!( - ::std::mem::size_of::(), - 88usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xDestroy) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_backup { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_api_routines { - pub aggregate_context: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub aggregate_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, - >, - pub bind_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_double: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, - ) -> ::std::os::raw::c_int, - >, - pub bind_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_int64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, - ) -> ::std::os::raw::c_int, - >, - pub bind_null: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub bind_parameter_index: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub bind_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub busy_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub busy_timeout: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub changes: - ::std::option::Option ::std::os::raw::c_int>, - pub close: - ::std::option::Option ::std::os::raw::c_int>, - pub collation_needed: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub collation_needed16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub column_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_bytes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_bytes16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub column_database_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_database_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_decltype: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_decltype16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_double: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, - >, - pub column_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_int64: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, - >, - pub column_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_origin_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_origin_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_table_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_table_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_uchar, - >, - pub column_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_type: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *mut sqlite3_value, - >, - pub commit_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub complete: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, - pub complete16: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub create_collation: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_collation16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_function16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_module: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub data_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub db_handle: - ::std::option::Option *mut sqlite3>, - pub declare_vtab: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub enable_shared_cache: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub errcode: - ::std::option::Option ::std::os::raw::c_int>, - pub errmsg: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, - >, - pub errmsg16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, - >, - pub exec: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub expired: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub finalize: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub free: ::std::option::Option, - pub free_table: - ::std::option::Option, - pub get_autocommit: - ::std::option::Option ::std::os::raw::c_int>, - pub get_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub get_table: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub global_recover: ::std::option::Option ::std::os::raw::c_int>, - pub interruptx: ::std::option::Option, - pub last_insert_rowid: - ::std::option::Option sqlite_int64>, - pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, - pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, - pub malloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub mprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub open16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub prepare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub profile: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub progress_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, - ), - >, - pub realloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub reset: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub result_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_double: - ::std::option::Option, - pub result_error: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_error16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_int64: - ::std::option::Option, - pub result_null: ::std::option::Option, - pub result_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16be: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16le: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_value: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), - >, - pub rollback_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub set_authorizer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub set_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, - ), - >, - pub snprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub step: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub table_column_metadata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub thread_cleanup: ::std::option::Option, - pub total_changes: - ::std::option::Option ::std::os::raw::c_int>, - pub trace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub transfer_bindings: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, - ) -> ::std::os::raw::c_int, - >, - pub update_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub user_data: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, - >, - pub value_blob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_bytes16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_double: ::std::option::Option f64>, - pub value_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_int64: - ::std::option::Option sqlite_int64>, - pub value_numeric_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_text: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, - >, - pub value_text16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16be: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16le: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub vmprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char, - >, - pub overload_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub prepare_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub clear_bindings: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub create_module_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_zeroblob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_close: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, - ) -> ::std::os::raw::c_int, - >, - pub blob_read: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_write: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub create_collation_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub file_control: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub memory_highwater: - ::std::option::Option sqlite3_int64>, - pub memory_used: ::std::option::Option sqlite3_int64>, - pub mutex_alloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub mutex_enter: ::std::option::Option, - pub mutex_free: ::std::option::Option, - pub mutex_leave: ::std::option::Option, - pub mutex_try: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub open_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub release_memory: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub result_error_nomem: ::std::option::Option, - pub result_error_toobig: - ::std::option::Option, - pub sleep: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub soft_heap_limit: ::std::option::Option, - pub vfs_find: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, - >, - pub vfs_register: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub vfs_unregister: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, - >, - pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, - pub result_zeroblob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_error_code: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub test_control: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, - >, - pub randomness: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), - >, - pub context_db_handle: - ::std::option::Option *mut sqlite3>, - pub extended_result_codes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub limit: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub next_stmt: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, - >, - pub sql: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, - >, - pub status: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_api_routines() { - assert_eq!( - ::std::mem::size_of::(), - 1240usize, - concat!("Size of: ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_context as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_context) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_count as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_double as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_count as *const _ - as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_index as *const _ - as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_index) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_name as *const _ - as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_text16 as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_handler as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_handler) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_timeout as *const _ as usize - }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_timeout) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(close) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed as *const _ as usize - }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_blob as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes as *const _ as usize - }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize - }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_count as *const _ as usize - }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name as *const _ - as usize - }, - 184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name16 as *const _ - as usize - }, - 192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype as *const _ as usize - }, - 200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize - }, - 208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_double as *const _ as usize - }, - 216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, - 224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_int64 as *const _ as usize - }, - 232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name as *const _ as usize - }, - 240usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name16 as *const _ as usize - }, - 248usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name as *const _ as usize - }, - 256usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name16 as *const _ - as usize - }, - 264usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name as *const _ as usize - }, - 272usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name16 as *const _ - as usize - }, - 280usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text as *const _ as usize - }, - 288usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text16 as *const _ as usize - }, - 296usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_type as *const _ as usize - }, - 304usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_type) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_value as *const _ as usize - }, - 312usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).commit_hook as *const _ as usize - }, - 320usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(commit_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, - 328usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, - 336usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation as *const _ as usize - }, - 344usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation16 as *const _ as usize - }, - 352usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function as *const _ as usize - }, - 360usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function16 as *const _ as usize - }, - 368usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module as *const _ as usize - }, - 376usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, - 384usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(data_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, - 392usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).declare_vtab as *const _ as usize - }, - 400usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(declare_vtab) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).enable_shared_cache as *const _ - as usize - }, - 408usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(enable_shared_cache) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, - 416usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, - 424usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, - 432usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, - 440usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(exec) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, - 448usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(expired) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, - 456usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(finalize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, - 464usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, - 472usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_autocommit as *const _ as usize - }, - 480usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_autocommit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_auxdata as *const _ as usize - }, - 488usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, - 496usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).global_recover as *const _ as usize - }, - 504usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(global_recover) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, - 512usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(interruptx) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize - }, - 520usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(last_insert_rowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, - 528usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).libversion_number as *const _ as usize - }, - 536usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion_number) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, - 544usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(malloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, - 552usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, - 560usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, - 568usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, - 576usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, - 584usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, - 592usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(profile) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).progress_handler as *const _ as usize - }, - 600usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(progress_handler) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, - 608usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(realloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, - 616usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(reset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_blob as *const _ as usize - }, - 624usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_double as *const _ as usize - }, - 632usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_double) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error as *const _ as usize - }, - 640usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error16 as *const _ as usize - }, - 648usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, - 656usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_int64 as *const _ as usize - }, - 664usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_null as *const _ as usize - }, - 672usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text as *const _ as usize - }, - 680usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16 as *const _ as usize - }, - 688usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16be as *const _ as usize - }, - 696usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16le as *const _ as usize - }, - 704usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16le) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_value as *const _ as usize - }, - 712usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rollback_hook as *const _ as usize - }, - 720usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(rollback_hook) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_authorizer as *const _ as usize - }, - 728usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_authorizer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_auxdata as *const _ as usize - }, - 736usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).snprintf as *const _ as usize }, - 744usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(snprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, - 752usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(step) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).table_column_metadata as *const _ - as usize - }, - 760usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(table_column_metadata) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize - }, - 768usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(thread_cleanup) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).total_changes as *const _ as usize - }, - 776usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(total_changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, - 784usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(trace) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize - }, - 792usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(transfer_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).update_hook as *const _ as usize - }, - 800usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(update_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, - 808usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(user_data) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, - 816usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes as *const _ as usize - }, - 824usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize - }, - 832usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_double as *const _ as usize - }, - 840usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, - 848usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_int64 as *const _ as usize - }, - 856usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize - }, - 864usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_numeric_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, - 872usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16 as *const _ as usize - }, - 880usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16be as *const _ as usize - }, - 888usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16le as *const _ as usize - }, - 896usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16le) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, - 904usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, - 912usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vmprintf) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).overload_function as *const _ as usize - }, - 920usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(overload_function) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, - 928usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize - }, - 936usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).clear_bindings as *const _ as usize - }, - 944usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(clear_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize - }, - 952usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize - }, - 960usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_zeroblob) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, - 968usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_bytes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, - 976usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_close) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, - 984usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, - 992usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_read) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, - 1000usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_write) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation_v2 as *const _ - as usize - }, - 1008usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).file_control as *const _ as usize - }, - 1016usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(file_control) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_highwater as *const _ as usize - }, - 1024usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_highwater) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_used as *const _ as usize - }, - 1032usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_used) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize - }, - 1040usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_alloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_enter as *const _ as usize - }, - 1048usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_enter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, - 1056usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_free) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_leave as *const _ as usize - }, - 1064usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_leave) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, - 1072usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_try) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, - 1080usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).release_memory as *const _ as usize - }, - 1088usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(release_memory) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize - }, - 1096usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_nomem) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_toobig as *const _ - as usize - }, - 1104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_toobig) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, - 1112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sleep) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize - }, - 1120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(soft_heap_limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, - 1128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_find) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_register as *const _ as usize - }, - 1136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_register) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize - }, - 1144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_unregister) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize - }, - 1152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(xthreadsafe) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize - }, - 1160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_zeroblob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_code as *const _ as usize - }, - 1168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_code) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).test_control as *const _ as usize - }, - 1176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(test_control) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, - 1184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(randomness) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).context_db_handle as *const _ as usize - }, - 1192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(context_db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).extended_result_codes as *const _ - as usize - }, - 1200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(extended_result_codes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, - 1208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, - 1216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(next_stmt) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, - 1224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sql) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, - 1232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(status) - ) - ); -} -pub type __builtin_va_list = [__va_list_tag; 1usize]; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct __va_list_tag { - pub gp_offset: ::std::os::raw::c_uint, - pub fp_offset: ::std::os::raw::c_uint, - pub overflow_arg_area: *mut ::std::os::raw::c_void, - pub reg_save_area: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout___va_list_tag() { - assert_eq!( - ::std::mem::size_of::<__va_list_tag>(), - 24usize, - concat!("Size of: ", stringify!(__va_list_tag)) - ); - assert_eq!( - ::std::mem::align_of::<__va_list_tag>(), - 8usize, - concat!("Alignment of ", stringify!(__va_list_tag)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(gp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(fp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(overflow_arg_area) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(reg_save_area) - ) - ); -} - -// bindings were built with loadable_extension_embedded: -// define sqlite3_api as an extern since this code will be embedded -// within a loadable extension that defines and exports this itself -extern "C" { - #[no_mangle] - pub static mut sqlite3_api: *mut sqlite3_api_routines; -} - -// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) - -pub unsafe fn sqlite3_aggregate_context( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_context.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_context", - " function" - )))(arg1, nBytes) -} - -pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_blob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_blob", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_double( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_double", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_null( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_null", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_parameter_index( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_index.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_index", - " function" - )))(arg1, zName) -} - -pub unsafe fn sqlite3_bind_parameter_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_text( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_text16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_bind_value( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_value", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_handler( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_handler", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_timeout( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_timeout.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_timeout", - " function" - )))(arg1, ms) -} - -pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_collation_needed( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_collation_needed16( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_column_blob( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_blob", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_column_database_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_database_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_decltype( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype", - " function" - )))(arg1, i) -} - -pub unsafe fn sqlite3_column_decltype16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_double", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int64( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int64", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_text( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_text16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_type( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_type", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_value( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_value", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_commit_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).commit_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "commit_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete16", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_create_collation( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_collation16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_function( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_function16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function16", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_module( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).data_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "data_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_declare_vtab( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).declare_vtab.expect(stringify!( - "sqlite3_api contains null pointer for ", - "declare_vtab", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).enable_shared_cache.expect(stringify!( - "sqlite3_api contains null pointer for ", - "enable_shared_cache", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errcode", - " function" - )))(db) -} - -pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_exec( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).exec.expect(stringify!( - "sqlite3_api contains null pointer for ", - "exec", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).expired.expect(stringify!( - "sqlite3_api contains null pointer for ", - "expired", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).finalize.expect(stringify!( - "sqlite3_api contains null pointer for ", - "finalize", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free_table", - " function" - )))(result) -} - -pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_autocommit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_autocommit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_get_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_auxdata", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_get_table( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_table", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).global_recover.expect(stringify!( - "sqlite3_api contains null pointer for ", - "global_recover", - " function" - )))() -} - -pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).interruptx.expect(stringify!( - "sqlite3_api contains null pointer for ", - "interruptx", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).last_insert_rowid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "last_insert_rowid", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion", - " function" - )))() -} - -pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion_number.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion_number", - " function" - )))() -} - -pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).malloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "malloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mprintf( - arg1: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mprintf", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_open( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_open16( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_prepare( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_profile( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).profile.expect(stringify!( - "sqlite3_api contains null pointer for ", - "profile", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_progress_handler( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).progress_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "progress_handler", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_realloc( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).realloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "realloc", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).reset.expect(stringify!( - "sqlite3_api contains null pointer for ", - "reset", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_result_blob( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_blob", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_double", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_error16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_null", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_text( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16be( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16be", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16le( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16le", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_value", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_rollback_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).rollback_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "rollback_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_authorizer( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_authorizer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_authorizer", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_auxdata", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_snprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).snprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "snprintf", - " function" - )))(arg1, arg2, arg3, vararg1) -} - -pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).step.expect(stringify!( - "sqlite3_api contains null pointer for ", - "step", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_table_column_metadata( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).table_column_metadata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "table_column_metadata", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) -} - -pub unsafe fn sqlite3_thread_cleanup() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).thread_cleanup.expect(stringify!( - "sqlite3_api contains null pointer for ", - "thread_cleanup", - " function" - )))() -} - -pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).total_changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "total_changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_trace( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).trace.expect(stringify!( - "sqlite3_api contains null pointer for ", - "trace", - " function" - )))(arg1, xTrace, arg2) -} - -pub unsafe fn sqlite3_transfer_bindings( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).transfer_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "transfer_bindings", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_update_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).update_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "update_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).user_data.expect(stringify!( - "sqlite3_api contains null pointer for ", - "user_data", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_blob", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_double", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_numeric_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_numeric_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16be", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16le", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vmprintf( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vmprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vmprintf", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_overload_function( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).overload_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "overload_function", - " function" - )))(arg1, zFuncName, nArg) -} - -pub unsafe fn sqlite3_prepare_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).clear_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "clear_bindings", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_module_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module_v2", - " function" - )))(arg1, arg2, arg3, arg4, xDestroy) -} - -pub unsafe fn sqlite3_bind_zeroblob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_zeroblob", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_open( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_open", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) -} - -pub unsafe fn sqlite3_blob_read( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_read.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_read", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_blob_write( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_write.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_write", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_create_collation_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_file_control( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).file_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "file_control", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_highwater.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_highwater", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_used.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_used", - " function" - )))() -} - -pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_alloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_alloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_enter.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_enter", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_leave.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_leave", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_try.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_try", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_open_v2( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open_v2", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).release_memory.expect(stringify!( - "sqlite3_api contains null pointer for ", - "release_memory", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_nomem.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_nomem", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_toobig.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_toobig", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sleep.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sleep", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).soft_heap_limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "soft_heap_limit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_find.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_find", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_register( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_register.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_register", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_unregister.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_unregister", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).xthreadsafe.expect(stringify!( - "sqlite3_api contains null pointer for ", - "xthreadsafe", - " function" - )))() -} - -pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_zeroblob", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_code.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_code", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_test_control( - arg1: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).test_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "test_control", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).randomness.expect(stringify!( - "sqlite3_api contains null pointer for ", - "randomness", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).context_db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "context_db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_extended_result_codes( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).extended_result_codes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "extended_result_codes", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_limit( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "limit", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).next_stmt.expect(stringify!( - "sqlite3_api contains null pointer for ", - "next_stmt", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sql.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sql", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_status( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "status", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub const SQLITE_DETERMINISTIC: i32 = 2048; diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23-ext.rs deleted file mode 100644 index d38ed33e6..000000000 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23-ext.rs +++ /dev/null @@ -1,6853 +0,0 @@ -/* automatically generated by rust-bindgen */ - -pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.6.23\0"; -pub const SQLITE_VERSION_NUMBER: i32 = 3006023; -pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = - b"2010-03-09 19:31:43 4ae453ea7be69018d8c16eb8dabe05617397dc4d\0"; -pub const SQLITE_OK: i32 = 0; -pub const SQLITE_ERROR: i32 = 1; -pub const SQLITE_INTERNAL: i32 = 2; -pub const SQLITE_PERM: i32 = 3; -pub const SQLITE_ABORT: i32 = 4; -pub const SQLITE_BUSY: i32 = 5; -pub const SQLITE_LOCKED: i32 = 6; -pub const SQLITE_NOMEM: i32 = 7; -pub const SQLITE_READONLY: i32 = 8; -pub const SQLITE_INTERRUPT: i32 = 9; -pub const SQLITE_IOERR: i32 = 10; -pub const SQLITE_CORRUPT: i32 = 11; -pub const SQLITE_NOTFOUND: i32 = 12; -pub const SQLITE_FULL: i32 = 13; -pub const SQLITE_CANTOPEN: i32 = 14; -pub const SQLITE_PROTOCOL: i32 = 15; -pub const SQLITE_EMPTY: i32 = 16; -pub const SQLITE_SCHEMA: i32 = 17; -pub const SQLITE_TOOBIG: i32 = 18; -pub const SQLITE_CONSTRAINT: i32 = 19; -pub const SQLITE_MISMATCH: i32 = 20; -pub const SQLITE_MISUSE: i32 = 21; -pub const SQLITE_NOLFS: i32 = 22; -pub const SQLITE_AUTH: i32 = 23; -pub const SQLITE_FORMAT: i32 = 24; -pub const SQLITE_RANGE: i32 = 25; -pub const SQLITE_NOTADB: i32 = 26; -pub const SQLITE_ROW: i32 = 100; -pub const SQLITE_DONE: i32 = 101; -pub const SQLITE_IOERR_READ: i32 = 266; -pub const SQLITE_IOERR_SHORT_READ: i32 = 522; -pub const SQLITE_IOERR_WRITE: i32 = 778; -pub const SQLITE_IOERR_FSYNC: i32 = 1034; -pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; -pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; -pub const SQLITE_IOERR_FSTAT: i32 = 1802; -pub const SQLITE_IOERR_UNLOCK: i32 = 2058; -pub const SQLITE_IOERR_RDLOCK: i32 = 2314; -pub const SQLITE_IOERR_DELETE: i32 = 2570; -pub const SQLITE_IOERR_BLOCKED: i32 = 2826; -pub const SQLITE_IOERR_NOMEM: i32 = 3082; -pub const SQLITE_IOERR_ACCESS: i32 = 3338; -pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; -pub const SQLITE_IOERR_LOCK: i32 = 3850; -pub const SQLITE_IOERR_CLOSE: i32 = 4106; -pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; -pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; -pub const SQLITE_OPEN_READONLY: i32 = 1; -pub const SQLITE_OPEN_READWRITE: i32 = 2; -pub const SQLITE_OPEN_CREATE: i32 = 4; -pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; -pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; -pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; -pub const SQLITE_OPEN_MAIN_DB: i32 = 256; -pub const SQLITE_OPEN_TEMP_DB: i32 = 512; -pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; -pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; -pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; -pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; -pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; -pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; -pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; -pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; -pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; -pub const SQLITE_IOCAP_ATOMIC: i32 = 1; -pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; -pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; -pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; -pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; -pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; -pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; -pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; -pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; -pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; -pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; -pub const SQLITE_LOCK_NONE: i32 = 0; -pub const SQLITE_LOCK_SHARED: i32 = 1; -pub const SQLITE_LOCK_RESERVED: i32 = 2; -pub const SQLITE_LOCK_PENDING: i32 = 3; -pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; -pub const SQLITE_SYNC_NORMAL: i32 = 2; -pub const SQLITE_SYNC_FULL: i32 = 3; -pub const SQLITE_SYNC_DATAONLY: i32 = 16; -pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; -pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_LAST_ERRNO: i32 = 4; -pub const SQLITE_ACCESS_EXISTS: i32 = 0; -pub const SQLITE_ACCESS_READWRITE: i32 = 1; -pub const SQLITE_ACCESS_READ: i32 = 2; -pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; -pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; -pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; -pub const SQLITE_CONFIG_MALLOC: i32 = 4; -pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; -pub const SQLITE_CONFIG_SCRATCH: i32 = 6; -pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; -pub const SQLITE_CONFIG_HEAP: i32 = 8; -pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; -pub const SQLITE_CONFIG_MUTEX: i32 = 10; -pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; -pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; -pub const SQLITE_CONFIG_PCACHE: i32 = 14; -pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; -pub const SQLITE_CONFIG_LOG: i32 = 16; -pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; -pub const SQLITE_DENY: i32 = 1; -pub const SQLITE_IGNORE: i32 = 2; -pub const SQLITE_CREATE_INDEX: i32 = 1; -pub const SQLITE_CREATE_TABLE: i32 = 2; -pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; -pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; -pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; -pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; -pub const SQLITE_CREATE_TRIGGER: i32 = 7; -pub const SQLITE_CREATE_VIEW: i32 = 8; -pub const SQLITE_DELETE: i32 = 9; -pub const SQLITE_DROP_INDEX: i32 = 10; -pub const SQLITE_DROP_TABLE: i32 = 11; -pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; -pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; -pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; -pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; -pub const SQLITE_DROP_TRIGGER: i32 = 16; -pub const SQLITE_DROP_VIEW: i32 = 17; -pub const SQLITE_INSERT: i32 = 18; -pub const SQLITE_PRAGMA: i32 = 19; -pub const SQLITE_READ: i32 = 20; -pub const SQLITE_SELECT: i32 = 21; -pub const SQLITE_TRANSACTION: i32 = 22; -pub const SQLITE_UPDATE: i32 = 23; -pub const SQLITE_ATTACH: i32 = 24; -pub const SQLITE_DETACH: i32 = 25; -pub const SQLITE_ALTER_TABLE: i32 = 26; -pub const SQLITE_REINDEX: i32 = 27; -pub const SQLITE_ANALYZE: i32 = 28; -pub const SQLITE_CREATE_VTABLE: i32 = 29; -pub const SQLITE_DROP_VTABLE: i32 = 30; -pub const SQLITE_FUNCTION: i32 = 31; -pub const SQLITE_SAVEPOINT: i32 = 32; -pub const SQLITE_COPY: i32 = 0; -pub const SQLITE_LIMIT_LENGTH: i32 = 0; -pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; -pub const SQLITE_LIMIT_COLUMN: i32 = 2; -pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; -pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; -pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; -pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; -pub const SQLITE_LIMIT_ATTACHED: i32 = 7; -pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; -pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; -pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; -pub const SQLITE_INTEGER: i32 = 1; -pub const SQLITE_FLOAT: i32 = 2; -pub const SQLITE_BLOB: i32 = 4; -pub const SQLITE_NULL: i32 = 5; -pub const SQLITE_TEXT: i32 = 3; -pub const SQLITE3_TEXT: i32 = 3; -pub const SQLITE_UTF8: i32 = 1; -pub const SQLITE_UTF16LE: i32 = 2; -pub const SQLITE_UTF16BE: i32 = 3; -pub const SQLITE_UTF16: i32 = 4; -pub const SQLITE_ANY: i32 = 5; -pub const SQLITE_UTF16_ALIGNED: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; -pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; -pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; -pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; -pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; -pub const SQLITE_MUTEX_FAST: i32 = 0; -pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; -pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; -pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; -pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; -pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; -pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; -pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; -pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; -pub const SQLITE_TESTCTRL_FIRST: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; -pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; -pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; -pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; -pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; -pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; -pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; -pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; -pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; -pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; -pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; -pub const SQLITE_TESTCTRL_LAST: i32 = 16; -pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; -pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; -pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; -pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; -pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; -pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; -pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; -pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; -pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; -pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; -pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; -pub const SQLITE_STMTSTATUS_SORT: i32 = 2; -pub type va_list = __builtin_va_list; -pub type __gnuc_va_list = __builtin_va_list; -extern "C" { - #[link_name = "\u{1}sqlite3_version"] - pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3 { - _unused: [u8; 0], -} -pub type sqlite_int64 = ::std::os::raw::c_longlong; -pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; -pub type sqlite3_int64 = sqlite_int64; -pub type sqlite3_uint64 = sqlite_uint64; -pub type sqlite3_callback = ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_file { - pub pMethods: *const sqlite3_io_methods, -} -#[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_file)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_file)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_file), - "::", - stringify!(pMethods) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_io_methods { - pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xRead: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *mut ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xWrite: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *const ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pSize: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xUnlock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCheckReservedLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileControl: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - op: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xSectorSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xDeviceCharacteristics: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_io_methods() { - assert_eq!( - ::std::mem::size_of::(), - 104usize, - concat!("Size of: ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xRead) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xWrite) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnlock) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xCheckReservedLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileControl) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSectorSize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ - as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xDeviceCharacteristics) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vfs { - pub iVersion: ::std::os::raw::c_int, - pub szOsFile: ::std::os::raw::c_int, - pub mxPathname: ::std::os::raw::c_int, - pub pNext: *mut sqlite3_vfs, - pub zName: *const ::std::os::raw::c_char, - pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - pOutFlags: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - syncDir: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xAccess: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - flags: ::std::os::raw::c_int, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFullPathname: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - nOut: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xDlOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zFilename: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void, - >, - pub xDlError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zErrMsg: *mut ::std::os::raw::c_char, - ), - >, - pub xDlSym: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ) -> ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ), - >, - >, - pub xDlClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), - >, - pub xRandomness: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSleep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - microseconds: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTime: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, - >, - pub xGetLastError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!( - ::std::mem::size_of::(), - 136usize, - concat!("Size of: ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(szOsFile) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(mxPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(zName) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pAppData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xAccess) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xFullPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlSym) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xRandomness) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSleep) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTime) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetLastError) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xRoundup: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub pAppData: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!( - ::std::mem::size_of::(), - 64usize, - concat!("Size of: ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xMalloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xFree) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRealloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRoundup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(pAppData) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Mem { - _unused: [u8; 0], -} -pub type sqlite3_value = Mem; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_context { - _unused: [u8; 0], -} -pub type sqlite3_destructor_type = - ::std::option::Option; -extern "C" { - #[link_name = "\u{1}sqlite3_temp_directory"] - pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xConnect: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xBestIndex: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: *mut sqlite3_index_info, - ) -> ::std::os::raw::c_int, - >, - pub xDisconnect: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xDestroy: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - ppCursor: *mut *mut sqlite3_vtab_cursor, - ) -> ::std::os::raw::c_int, - >, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xFilter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - idxNum: ::std::os::raw::c_int, - idxStr: *const ::std::os::raw::c_char, - argc: ::std::os::raw::c_int, - argv: *mut *mut sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub xNext: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xEof: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - arg2: *mut sqlite3_context, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - pRowid: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xUpdate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - arg4: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xBegin: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xCommit: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xRollback: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xFindFunction: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - nArg: ::std::os::raw::c_int, - zName: *const ::std::os::raw::c_char, - pxFunc: *mut ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - ppArg: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xRename: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - zNew: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!( - ::std::mem::size_of::(), - 160usize, - concat!("Size of: ", stringify!(sqlite3_module)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_module)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xConnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBestIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDisconnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFilter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xEof) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xColumn) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xUpdate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBegin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCommit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollback) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFindFunction) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRename) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info { - pub nConstraint: ::std::os::raw::c_int, - pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, - pub nOrderBy: ::std::os::raw::c_int, - pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, - pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, - pub idxNum: ::std::os::raw::c_int, - pub idxStr: *mut ::std::os::raw::c_char, - pub needToFreeIdxStr: ::std::os::raw::c_int, - pub orderByConsumed: ::std::os::raw::c_int, - pub estimatedCost: f64, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint { - pub iColumn: ::std::os::raw::c_int, - pub op: ::std::os::raw::c_uchar, - pub usable: ::std::os::raw::c_uchar, - pub iTermOffset: ::std::os::raw::c_int, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).op as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(op) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).usable - as *const _ as usize - }, - 5usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(usable) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iTermOffset - as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iTermOffset) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_orderby { - pub iColumn: ::std::os::raw::c_int, - pub desc: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).desc as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(desc) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint_usage { - pub argvIndex: ::std::os::raw::c_int, - pub omit: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).argvIndex - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(argvIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).omit - as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(omit) - ) - ); -} -#[test] -fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nOrderBy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aOrderBy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraintUsage) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxNum) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(needToFreeIdxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(orderByConsumed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedCost as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedCost) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(pModule) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(nRef) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(zErrMsg) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab_cursor { - pub pVtab: *mut sqlite3_vtab, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab_cursor), - "::", - stringify!(pVtab) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexNotheld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexInit as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnd) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexAlloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexFree as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexFree) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexTry) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexLeave) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexHeld) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexNotheld) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods { - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!( - ::std::mem::size_of::(), - 88usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xDestroy) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_backup { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_api_routines { - pub aggregate_context: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub aggregate_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, - >, - pub bind_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_double: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, - ) -> ::std::os::raw::c_int, - >, - pub bind_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_int64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, - ) -> ::std::os::raw::c_int, - >, - pub bind_null: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub bind_parameter_index: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub bind_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub busy_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub busy_timeout: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub changes: - ::std::option::Option ::std::os::raw::c_int>, - pub close: - ::std::option::Option ::std::os::raw::c_int>, - pub collation_needed: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub collation_needed16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub column_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_bytes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_bytes16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub column_database_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_database_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_decltype: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_decltype16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_double: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, - >, - pub column_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_int64: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, - >, - pub column_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_origin_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_origin_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_table_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_table_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_uchar, - >, - pub column_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_type: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *mut sqlite3_value, - >, - pub commit_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub complete: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, - pub complete16: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub create_collation: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_collation16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_function16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_module: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub data_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub db_handle: - ::std::option::Option *mut sqlite3>, - pub declare_vtab: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub enable_shared_cache: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub errcode: - ::std::option::Option ::std::os::raw::c_int>, - pub errmsg: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, - >, - pub errmsg16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, - >, - pub exec: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub expired: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub finalize: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub free: ::std::option::Option, - pub free_table: - ::std::option::Option, - pub get_autocommit: - ::std::option::Option ::std::os::raw::c_int>, - pub get_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub get_table: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub global_recover: ::std::option::Option ::std::os::raw::c_int>, - pub interruptx: ::std::option::Option, - pub last_insert_rowid: - ::std::option::Option sqlite_int64>, - pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, - pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, - pub malloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub mprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub open16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub prepare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub profile: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub progress_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, - ), - >, - pub realloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub reset: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub result_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_double: - ::std::option::Option, - pub result_error: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_error16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_int64: - ::std::option::Option, - pub result_null: ::std::option::Option, - pub result_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16be: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16le: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_value: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), - >, - pub rollback_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub set_authorizer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub set_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, - ), - >, - pub snprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub step: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub table_column_metadata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub thread_cleanup: ::std::option::Option, - pub total_changes: - ::std::option::Option ::std::os::raw::c_int>, - pub trace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub transfer_bindings: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, - ) -> ::std::os::raw::c_int, - >, - pub update_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub user_data: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, - >, - pub value_blob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_bytes16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_double: ::std::option::Option f64>, - pub value_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_int64: - ::std::option::Option sqlite_int64>, - pub value_numeric_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_text: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, - >, - pub value_text16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16be: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16le: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub vmprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char, - >, - pub overload_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub prepare_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub clear_bindings: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub create_module_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_zeroblob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_close: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, - ) -> ::std::os::raw::c_int, - >, - pub blob_read: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_write: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub create_collation_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub file_control: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub memory_highwater: - ::std::option::Option sqlite3_int64>, - pub memory_used: ::std::option::Option sqlite3_int64>, - pub mutex_alloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub mutex_enter: ::std::option::Option, - pub mutex_free: ::std::option::Option, - pub mutex_leave: ::std::option::Option, - pub mutex_try: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub open_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub release_memory: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub result_error_nomem: ::std::option::Option, - pub result_error_toobig: - ::std::option::Option, - pub sleep: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub soft_heap_limit: ::std::option::Option, - pub vfs_find: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, - >, - pub vfs_register: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub vfs_unregister: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, - >, - pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, - pub result_zeroblob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_error_code: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub test_control: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, - >, - pub randomness: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), - >, - pub context_db_handle: - ::std::option::Option *mut sqlite3>, - pub extended_result_codes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub limit: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub next_stmt: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, - >, - pub sql: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, - >, - pub status: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_api_routines() { - assert_eq!( - ::std::mem::size_of::(), - 1240usize, - concat!("Size of: ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_context as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_context) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_count as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_double as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_count as *const _ - as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_index as *const _ - as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_index) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_name as *const _ - as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_text16 as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_handler as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_handler) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_timeout as *const _ as usize - }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_timeout) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(close) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed as *const _ as usize - }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_blob as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes as *const _ as usize - }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize - }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_count as *const _ as usize - }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name as *const _ - as usize - }, - 184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name16 as *const _ - as usize - }, - 192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype as *const _ as usize - }, - 200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize - }, - 208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_double as *const _ as usize - }, - 216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, - 224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_int64 as *const _ as usize - }, - 232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name as *const _ as usize - }, - 240usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name16 as *const _ as usize - }, - 248usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name as *const _ as usize - }, - 256usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name16 as *const _ - as usize - }, - 264usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name as *const _ as usize - }, - 272usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name16 as *const _ - as usize - }, - 280usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text as *const _ as usize - }, - 288usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text16 as *const _ as usize - }, - 296usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_type as *const _ as usize - }, - 304usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_type) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_value as *const _ as usize - }, - 312usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).commit_hook as *const _ as usize - }, - 320usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(commit_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, - 328usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, - 336usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation as *const _ as usize - }, - 344usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation16 as *const _ as usize - }, - 352usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function as *const _ as usize - }, - 360usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function16 as *const _ as usize - }, - 368usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module as *const _ as usize - }, - 376usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, - 384usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(data_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, - 392usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).declare_vtab as *const _ as usize - }, - 400usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(declare_vtab) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).enable_shared_cache as *const _ - as usize - }, - 408usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(enable_shared_cache) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, - 416usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, - 424usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, - 432usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, - 440usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(exec) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, - 448usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(expired) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, - 456usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(finalize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, - 464usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, - 472usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_autocommit as *const _ as usize - }, - 480usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_autocommit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_auxdata as *const _ as usize - }, - 488usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, - 496usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).global_recover as *const _ as usize - }, - 504usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(global_recover) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, - 512usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(interruptx) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize - }, - 520usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(last_insert_rowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, - 528usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).libversion_number as *const _ as usize - }, - 536usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion_number) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, - 544usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(malloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, - 552usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, - 560usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, - 568usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, - 576usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, - 584usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, - 592usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(profile) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).progress_handler as *const _ as usize - }, - 600usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(progress_handler) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, - 608usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(realloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, - 616usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(reset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_blob as *const _ as usize - }, - 624usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_double as *const _ as usize - }, - 632usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_double) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error as *const _ as usize - }, - 640usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error16 as *const _ as usize - }, - 648usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, - 656usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_int64 as *const _ as usize - }, - 664usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_null as *const _ as usize - }, - 672usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text as *const _ as usize - }, - 680usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16 as *const _ as usize - }, - 688usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16be as *const _ as usize - }, - 696usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16le as *const _ as usize - }, - 704usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16le) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_value as *const _ as usize - }, - 712usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rollback_hook as *const _ as usize - }, - 720usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(rollback_hook) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_authorizer as *const _ as usize - }, - 728usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_authorizer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_auxdata as *const _ as usize - }, - 736usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).snprintf as *const _ as usize }, - 744usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(snprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, - 752usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(step) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).table_column_metadata as *const _ - as usize - }, - 760usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(table_column_metadata) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize - }, - 768usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(thread_cleanup) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).total_changes as *const _ as usize - }, - 776usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(total_changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, - 784usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(trace) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize - }, - 792usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(transfer_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).update_hook as *const _ as usize - }, - 800usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(update_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, - 808usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(user_data) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, - 816usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes as *const _ as usize - }, - 824usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize - }, - 832usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_double as *const _ as usize - }, - 840usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, - 848usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_int64 as *const _ as usize - }, - 856usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize - }, - 864usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_numeric_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, - 872usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16 as *const _ as usize - }, - 880usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16be as *const _ as usize - }, - 888usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16le as *const _ as usize - }, - 896usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16le) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, - 904usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, - 912usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vmprintf) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).overload_function as *const _ as usize - }, - 920usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(overload_function) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, - 928usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize - }, - 936usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).clear_bindings as *const _ as usize - }, - 944usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(clear_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize - }, - 952usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize - }, - 960usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_zeroblob) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, - 968usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_bytes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, - 976usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_close) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, - 984usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, - 992usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_read) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, - 1000usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_write) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation_v2 as *const _ - as usize - }, - 1008usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).file_control as *const _ as usize - }, - 1016usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(file_control) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_highwater as *const _ as usize - }, - 1024usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_highwater) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_used as *const _ as usize - }, - 1032usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_used) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize - }, - 1040usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_alloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_enter as *const _ as usize - }, - 1048usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_enter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, - 1056usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_free) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_leave as *const _ as usize - }, - 1064usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_leave) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, - 1072usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_try) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, - 1080usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).release_memory as *const _ as usize - }, - 1088usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(release_memory) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize - }, - 1096usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_nomem) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_toobig as *const _ - as usize - }, - 1104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_toobig) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, - 1112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sleep) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize - }, - 1120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(soft_heap_limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, - 1128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_find) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_register as *const _ as usize - }, - 1136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_register) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize - }, - 1144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_unregister) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize - }, - 1152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(xthreadsafe) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize - }, - 1160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_zeroblob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_code as *const _ as usize - }, - 1168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_code) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).test_control as *const _ as usize - }, - 1176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(test_control) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, - 1184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(randomness) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).context_db_handle as *const _ as usize - }, - 1192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(context_db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).extended_result_codes as *const _ - as usize - }, - 1200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(extended_result_codes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, - 1208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, - 1216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(next_stmt) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, - 1224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sql) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, - 1232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(status) - ) - ); -} -pub type __builtin_va_list = [__va_list_tag; 1usize]; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct __va_list_tag { - pub gp_offset: ::std::os::raw::c_uint, - pub fp_offset: ::std::os::raw::c_uint, - pub overflow_arg_area: *mut ::std::os::raw::c_void, - pub reg_save_area: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout___va_list_tag() { - assert_eq!( - ::std::mem::size_of::<__va_list_tag>(), - 24usize, - concat!("Size of: ", stringify!(__va_list_tag)) - ); - assert_eq!( - ::std::mem::align_of::<__va_list_tag>(), - 8usize, - concat!("Alignment of ", stringify!(__va_list_tag)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(gp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(fp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(overflow_arg_area) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(reg_save_area) - ) - ); -} - -// bindings were built with (non-embedded) loadable_extension: -// we define our own sqlite_api static variable and export it -// to C -#[no_mangle] -pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_routines; - -// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) - -pub unsafe fn sqlite3_aggregate_context( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_context.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_context", - " function" - )))(arg1, nBytes) -} - -pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_blob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_blob", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_double( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_double", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_null( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_null", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_parameter_index( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_index.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_index", - " function" - )))(arg1, zName) -} - -pub unsafe fn sqlite3_bind_parameter_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_text( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_text16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_bind_value( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_value", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_handler( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_handler", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_timeout( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_timeout.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_timeout", - " function" - )))(arg1, ms) -} - -pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_collation_needed( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_collation_needed16( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_column_blob( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_blob", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_column_database_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_database_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_decltype( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype", - " function" - )))(arg1, i) -} - -pub unsafe fn sqlite3_column_decltype16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_double", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int64( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int64", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_text( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_text16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_type( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_type", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_value( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_value", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_commit_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).commit_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "commit_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete16", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_create_collation( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_collation16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_function( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_function16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function16", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_module( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).data_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "data_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_declare_vtab( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).declare_vtab.expect(stringify!( - "sqlite3_api contains null pointer for ", - "declare_vtab", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).enable_shared_cache.expect(stringify!( - "sqlite3_api contains null pointer for ", - "enable_shared_cache", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errcode", - " function" - )))(db) -} - -pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_exec( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).exec.expect(stringify!( - "sqlite3_api contains null pointer for ", - "exec", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).expired.expect(stringify!( - "sqlite3_api contains null pointer for ", - "expired", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).finalize.expect(stringify!( - "sqlite3_api contains null pointer for ", - "finalize", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free_table", - " function" - )))(result) -} - -pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_autocommit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_autocommit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_get_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_auxdata", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_get_table( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_table", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).global_recover.expect(stringify!( - "sqlite3_api contains null pointer for ", - "global_recover", - " function" - )))() -} - -pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).interruptx.expect(stringify!( - "sqlite3_api contains null pointer for ", - "interruptx", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).last_insert_rowid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "last_insert_rowid", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion", - " function" - )))() -} - -pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion_number.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion_number", - " function" - )))() -} - -pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).malloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "malloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mprintf( - arg1: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mprintf", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_open( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_open16( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_prepare( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_profile( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).profile.expect(stringify!( - "sqlite3_api contains null pointer for ", - "profile", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_progress_handler( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).progress_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "progress_handler", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_realloc( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).realloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "realloc", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).reset.expect(stringify!( - "sqlite3_api contains null pointer for ", - "reset", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_result_blob( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_blob", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_double", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_error16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_null", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_text( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16be( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16be", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16le( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16le", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_value", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_rollback_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).rollback_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "rollback_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_authorizer( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_authorizer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_authorizer", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_auxdata", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_snprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).snprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "snprintf", - " function" - )))(arg1, arg2, arg3, vararg1) -} - -pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).step.expect(stringify!( - "sqlite3_api contains null pointer for ", - "step", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_table_column_metadata( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).table_column_metadata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "table_column_metadata", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) -} - -pub unsafe fn sqlite3_thread_cleanup() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).thread_cleanup.expect(stringify!( - "sqlite3_api contains null pointer for ", - "thread_cleanup", - " function" - )))() -} - -pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).total_changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "total_changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_trace( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).trace.expect(stringify!( - "sqlite3_api contains null pointer for ", - "trace", - " function" - )))(arg1, xTrace, arg2) -} - -pub unsafe fn sqlite3_transfer_bindings( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).transfer_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "transfer_bindings", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_update_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).update_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "update_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).user_data.expect(stringify!( - "sqlite3_api contains null pointer for ", - "user_data", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_blob", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_double", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_numeric_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_numeric_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16be", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16le", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vmprintf( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vmprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vmprintf", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_overload_function( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).overload_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "overload_function", - " function" - )))(arg1, zFuncName, nArg) -} - -pub unsafe fn sqlite3_prepare_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).clear_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "clear_bindings", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_module_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module_v2", - " function" - )))(arg1, arg2, arg3, arg4, xDestroy) -} - -pub unsafe fn sqlite3_bind_zeroblob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_zeroblob", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_open( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_open", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) -} - -pub unsafe fn sqlite3_blob_read( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_read.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_read", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_blob_write( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_write.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_write", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_create_collation_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_file_control( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).file_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "file_control", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_highwater.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_highwater", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_used.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_used", - " function" - )))() -} - -pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_alloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_alloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_enter.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_enter", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_leave.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_leave", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_try.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_try", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_open_v2( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open_v2", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).release_memory.expect(stringify!( - "sqlite3_api contains null pointer for ", - "release_memory", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_nomem.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_nomem", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_toobig.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_toobig", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sleep.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sleep", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).soft_heap_limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "soft_heap_limit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_find.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_find", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_register( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_register.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_register", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_unregister.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_unregister", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).xthreadsafe.expect(stringify!( - "sqlite3_api contains null pointer for ", - "xthreadsafe", - " function" - )))() -} - -pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_zeroblob", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_code.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_code", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_test_control( - arg1: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).test_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "test_control", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).randomness.expect(stringify!( - "sqlite3_api contains null pointer for ", - "randomness", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).context_db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "context_db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_extended_result_codes( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).extended_result_codes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "extended_result_codes", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_limit( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "limit", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).next_stmt.expect(stringify!( - "sqlite3_api contains null pointer for ", - "next_stmt", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sql.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sql", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_status( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "status", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub const SQLITE_DETERMINISTIC: i32 = 2048; diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23.rs deleted file mode 100644 index 5fd7f84c5..000000000 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23.rs +++ /dev/null @@ -1,3103 +0,0 @@ -/* automatically generated by rust-bindgen */ - -pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.6.23\0"; -pub const SQLITE_VERSION_NUMBER: i32 = 3006023; -pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = - b"2010-03-09 19:31:43 4ae453ea7be69018d8c16eb8dabe05617397dc4d\0"; -pub const SQLITE_OK: i32 = 0; -pub const SQLITE_ERROR: i32 = 1; -pub const SQLITE_INTERNAL: i32 = 2; -pub const SQLITE_PERM: i32 = 3; -pub const SQLITE_ABORT: i32 = 4; -pub const SQLITE_BUSY: i32 = 5; -pub const SQLITE_LOCKED: i32 = 6; -pub const SQLITE_NOMEM: i32 = 7; -pub const SQLITE_READONLY: i32 = 8; -pub const SQLITE_INTERRUPT: i32 = 9; -pub const SQLITE_IOERR: i32 = 10; -pub const SQLITE_CORRUPT: i32 = 11; -pub const SQLITE_NOTFOUND: i32 = 12; -pub const SQLITE_FULL: i32 = 13; -pub const SQLITE_CANTOPEN: i32 = 14; -pub const SQLITE_PROTOCOL: i32 = 15; -pub const SQLITE_EMPTY: i32 = 16; -pub const SQLITE_SCHEMA: i32 = 17; -pub const SQLITE_TOOBIG: i32 = 18; -pub const SQLITE_CONSTRAINT: i32 = 19; -pub const SQLITE_MISMATCH: i32 = 20; -pub const SQLITE_MISUSE: i32 = 21; -pub const SQLITE_NOLFS: i32 = 22; -pub const SQLITE_AUTH: i32 = 23; -pub const SQLITE_FORMAT: i32 = 24; -pub const SQLITE_RANGE: i32 = 25; -pub const SQLITE_NOTADB: i32 = 26; -pub const SQLITE_ROW: i32 = 100; -pub const SQLITE_DONE: i32 = 101; -pub const SQLITE_IOERR_READ: i32 = 266; -pub const SQLITE_IOERR_SHORT_READ: i32 = 522; -pub const SQLITE_IOERR_WRITE: i32 = 778; -pub const SQLITE_IOERR_FSYNC: i32 = 1034; -pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; -pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; -pub const SQLITE_IOERR_FSTAT: i32 = 1802; -pub const SQLITE_IOERR_UNLOCK: i32 = 2058; -pub const SQLITE_IOERR_RDLOCK: i32 = 2314; -pub const SQLITE_IOERR_DELETE: i32 = 2570; -pub const SQLITE_IOERR_BLOCKED: i32 = 2826; -pub const SQLITE_IOERR_NOMEM: i32 = 3082; -pub const SQLITE_IOERR_ACCESS: i32 = 3338; -pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; -pub const SQLITE_IOERR_LOCK: i32 = 3850; -pub const SQLITE_IOERR_CLOSE: i32 = 4106; -pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; -pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; -pub const SQLITE_OPEN_READONLY: i32 = 1; -pub const SQLITE_OPEN_READWRITE: i32 = 2; -pub const SQLITE_OPEN_CREATE: i32 = 4; -pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; -pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; -pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; -pub const SQLITE_OPEN_MAIN_DB: i32 = 256; -pub const SQLITE_OPEN_TEMP_DB: i32 = 512; -pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; -pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; -pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; -pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; -pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; -pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; -pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; -pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; -pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; -pub const SQLITE_IOCAP_ATOMIC: i32 = 1; -pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; -pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; -pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; -pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; -pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; -pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; -pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; -pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; -pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; -pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; -pub const SQLITE_LOCK_NONE: i32 = 0; -pub const SQLITE_LOCK_SHARED: i32 = 1; -pub const SQLITE_LOCK_RESERVED: i32 = 2; -pub const SQLITE_LOCK_PENDING: i32 = 3; -pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; -pub const SQLITE_SYNC_NORMAL: i32 = 2; -pub const SQLITE_SYNC_FULL: i32 = 3; -pub const SQLITE_SYNC_DATAONLY: i32 = 16; -pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; -pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_LAST_ERRNO: i32 = 4; -pub const SQLITE_ACCESS_EXISTS: i32 = 0; -pub const SQLITE_ACCESS_READWRITE: i32 = 1; -pub const SQLITE_ACCESS_READ: i32 = 2; -pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; -pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; -pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; -pub const SQLITE_CONFIG_MALLOC: i32 = 4; -pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; -pub const SQLITE_CONFIG_SCRATCH: i32 = 6; -pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; -pub const SQLITE_CONFIG_HEAP: i32 = 8; -pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; -pub const SQLITE_CONFIG_MUTEX: i32 = 10; -pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; -pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; -pub const SQLITE_CONFIG_PCACHE: i32 = 14; -pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; -pub const SQLITE_CONFIG_LOG: i32 = 16; -pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; -pub const SQLITE_DENY: i32 = 1; -pub const SQLITE_IGNORE: i32 = 2; -pub const SQLITE_CREATE_INDEX: i32 = 1; -pub const SQLITE_CREATE_TABLE: i32 = 2; -pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; -pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; -pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; -pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; -pub const SQLITE_CREATE_TRIGGER: i32 = 7; -pub const SQLITE_CREATE_VIEW: i32 = 8; -pub const SQLITE_DELETE: i32 = 9; -pub const SQLITE_DROP_INDEX: i32 = 10; -pub const SQLITE_DROP_TABLE: i32 = 11; -pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; -pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; -pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; -pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; -pub const SQLITE_DROP_TRIGGER: i32 = 16; -pub const SQLITE_DROP_VIEW: i32 = 17; -pub const SQLITE_INSERT: i32 = 18; -pub const SQLITE_PRAGMA: i32 = 19; -pub const SQLITE_READ: i32 = 20; -pub const SQLITE_SELECT: i32 = 21; -pub const SQLITE_TRANSACTION: i32 = 22; -pub const SQLITE_UPDATE: i32 = 23; -pub const SQLITE_ATTACH: i32 = 24; -pub const SQLITE_DETACH: i32 = 25; -pub const SQLITE_ALTER_TABLE: i32 = 26; -pub const SQLITE_REINDEX: i32 = 27; -pub const SQLITE_ANALYZE: i32 = 28; -pub const SQLITE_CREATE_VTABLE: i32 = 29; -pub const SQLITE_DROP_VTABLE: i32 = 30; -pub const SQLITE_FUNCTION: i32 = 31; -pub const SQLITE_SAVEPOINT: i32 = 32; -pub const SQLITE_COPY: i32 = 0; -pub const SQLITE_LIMIT_LENGTH: i32 = 0; -pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; -pub const SQLITE_LIMIT_COLUMN: i32 = 2; -pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; -pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; -pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; -pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; -pub const SQLITE_LIMIT_ATTACHED: i32 = 7; -pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; -pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; -pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; -pub const SQLITE_INTEGER: i32 = 1; -pub const SQLITE_FLOAT: i32 = 2; -pub const SQLITE_BLOB: i32 = 4; -pub const SQLITE_NULL: i32 = 5; -pub const SQLITE_TEXT: i32 = 3; -pub const SQLITE3_TEXT: i32 = 3; -pub const SQLITE_UTF8: i32 = 1; -pub const SQLITE_UTF16LE: i32 = 2; -pub const SQLITE_UTF16BE: i32 = 3; -pub const SQLITE_UTF16: i32 = 4; -pub const SQLITE_ANY: i32 = 5; -pub const SQLITE_UTF16_ALIGNED: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; -pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; -pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; -pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; -pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; -pub const SQLITE_MUTEX_FAST: i32 = 0; -pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; -pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; -pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; -pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; -pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; -pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; -pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; -pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; -pub const SQLITE_TESTCTRL_FIRST: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; -pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; -pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; -pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; -pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; -pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; -pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; -pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; -pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; -pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; -pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; -pub const SQLITE_TESTCTRL_LAST: i32 = 16; -pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; -pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; -pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; -pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; -pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; -pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; -pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; -pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; -pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; -pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; -pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; -pub const SQLITE_STMTSTATUS_SORT: i32 = 2; -pub type va_list = __builtin_va_list; -pub type __gnuc_va_list = __builtin_va_list; -extern "C" { - #[link_name = "\u{1}sqlite3_version"] - pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; -} -extern "C" { - pub fn sqlite3_libversion() -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_sourceid() -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_libversion_number() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_compileoption_used( - zOptName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_compileoption_get(N: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_threadsafe() -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3 { - _unused: [u8; 0], -} -pub type sqlite_int64 = ::std::os::raw::c_longlong; -pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; -pub type sqlite3_int64 = sqlite_int64; -pub type sqlite3_uint64 = sqlite_uint64; -extern "C" { - pub fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -pub type sqlite3_callback = ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, ->; -extern "C" { - pub fn sqlite3_exec( - arg1: *mut sqlite3, - sql: *const ::std::os::raw::c_char, - callback: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg2: *mut ::std::os::raw::c_void, - errmsg: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_file { - pub pMethods: *const sqlite3_io_methods, -} -#[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_file)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_file)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_file), - "::", - stringify!(pMethods) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_io_methods { - pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xRead: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *mut ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xWrite: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *const ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pSize: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xUnlock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCheckReservedLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileControl: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - op: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xSectorSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xDeviceCharacteristics: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_io_methods() { - assert_eq!( - ::std::mem::size_of::(), - 104usize, - concat!("Size of: ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xRead) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xWrite) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnlock) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xCheckReservedLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileControl) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSectorSize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ - as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xDeviceCharacteristics) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vfs { - pub iVersion: ::std::os::raw::c_int, - pub szOsFile: ::std::os::raw::c_int, - pub mxPathname: ::std::os::raw::c_int, - pub pNext: *mut sqlite3_vfs, - pub zName: *const ::std::os::raw::c_char, - pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - pOutFlags: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - syncDir: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xAccess: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - flags: ::std::os::raw::c_int, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFullPathname: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - nOut: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xDlOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zFilename: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void, - >, - pub xDlError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zErrMsg: *mut ::std::os::raw::c_char, - ), - >, - pub xDlSym: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ) -> ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ), - >, - >, - pub xDlClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), - >, - pub xRandomness: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSleep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - microseconds: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTime: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, - >, - pub xGetLastError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!( - ::std::mem::size_of::(), - 136usize, - concat!("Size of: ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(szOsFile) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(mxPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(zName) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pAppData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xAccess) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xFullPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlSym) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xRandomness) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSleep) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTime) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetLastError) - ) - ); -} -extern "C" { - pub fn sqlite3_initialize() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_shutdown() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_os_init() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_os_end() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_db_config( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xRoundup: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub pAppData: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!( - ::std::mem::size_of::(), - 64usize, - concat!("Size of: ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xMalloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xFree) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRealloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRoundup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(pAppData) - ) - ); -} -extern "C" { - pub fn sqlite3_extended_result_codes( - arg1: *mut sqlite3, - onoff: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_interrupt(arg1: *mut sqlite3); -} -extern "C" { - pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_busy_handler( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_busy_timeout( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_get_table( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - pazResult: *mut *mut *mut ::std::os::raw::c_char, - pnRow: *mut ::std::os::raw::c_int, - pnColumn: *mut ::std::os::raw::c_int, - pzErrmsg: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char); -} -extern "C" { - pub fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char, ...) - -> *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_vmprintf( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_snprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_realloc( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_free(arg1: *mut ::std::os::raw::c_void); -} -extern "C" { - pub fn sqlite3_memory_used() -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_randomness(N: ::std::os::raw::c_int, P: *mut ::std::os::raw::c_void); -} -extern "C" { - pub fn sqlite3_set_authorizer( - arg1: *mut sqlite3, - xAuth: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pUserData: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_trace( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_profile( - arg1: *mut sqlite3, - xProfile: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_uint64, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_progress_handler( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, - ); -} -extern "C" { - pub fn sqlite3_open( - filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_open16( - filename: *const ::std::os::raw::c_void, - ppDb: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_open_v2( - filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3, - flags: ::std::os::raw::c_int, - zVfs: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_extended_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt { - _unused: [u8; 0], -} -extern "C" { - pub fn sqlite3_limit( - arg1: *mut sqlite3, - id: ::std::os::raw::c_int, - newVal: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_prepare( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_prepare_v2( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_prepare16( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_prepare16_v2( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Mem { - _unused: [u8; 0], -} -pub type sqlite3_value = Mem; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_context { - _unused: [u8; 0], -} -extern "C" { - pub fn sqlite3_bind_blob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_double( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_int( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_int64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_int64, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_null( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_text( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_text16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_value( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_zeroblob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - n: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_parameter_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_bind_parameter_index( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_name( - arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_column_name16( - arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_database_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_column_database_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_table_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_column_table_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_origin_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_column_origin_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_decltype( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_column_decltype16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_blob( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_bytes( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_bytes16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64; -} -extern "C" { - pub fn sqlite3_column_int( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_int64( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_column_text( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_uchar; -} -extern "C" { - pub fn sqlite3_column_text16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_type( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_value( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *mut sqlite3_value; -} -extern "C" { - pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function( - db: *mut sqlite3, - zFunctionName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function16( - db: *mut sqlite3, - zFunctionName: *const ::std::os::raw::c_void, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_transfer_bindings( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_global_recover() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_thread_cleanup(); -} -extern "C" { - pub fn sqlite3_memory_alarm( - arg1: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: sqlite3_int64, - arg3: ::std::os::raw::c_int, - ), - >, - arg2: *mut ::std::os::raw::c_void, - arg3: sqlite3_int64, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64; -} -extern "C" { - pub fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar; -} -extern "C" { - pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_aggregate_context( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3; -} -extern "C" { - pub fn sqlite3_get_auxdata( - arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_set_auxdata( - arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option, - ); -} -pub type sqlite3_destructor_type = - ::std::option::Option; -extern "C" { - pub fn sqlite3_result_blob( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64); -} -extern "C" { - pub fn sqlite3_result_error( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ); -} -extern "C" { - pub fn sqlite3_result_error16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - ); -} -extern "C" { - pub fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context); -} -extern "C" { - pub fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context); -} -extern "C" { - pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite3_int64); -} -extern "C" { - pub fn sqlite3_result_null(arg1: *mut sqlite3_context); -} -extern "C" { - pub fn sqlite3_result_text( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_text16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_text16le( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_text16be( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value); -} -extern "C" { - pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, n: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_create_collation( - arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - xCompare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation_v2( - arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - xCompare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation16( - arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_void, - eTextRep: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - xCompare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed16( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; -} -extern "C" { - #[link_name = "\u{1}sqlite3_temp_directory"] - pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3; -} -extern "C" { - pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) -> *mut sqlite3_stmt; -} -extern "C" { - pub fn sqlite3_commit_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_rollback_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_update_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_table_column_metadata( - db: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - zTableName: *const ::std::os::raw::c_char, - zColumnName: *const ::std::os::raw::c_char, - pzDataType: *mut *const ::std::os::raw::c_char, - pzCollSeq: *mut *const ::std::os::raw::c_char, - pNotNull: *mut ::std::os::raw::c_int, - pPrimaryKey: *mut ::std::os::raw::c_int, - pAutoinc: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_load_extension( - db: *mut sqlite3, - zFile: *const ::std::os::raw::c_char, - zProc: *const ::std::os::raw::c_char, - pzErrMsg: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_enable_load_extension( - db: *mut sqlite3, - onoff: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_auto_extension( - xEntryPoint: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_reset_auto_extension(); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xConnect: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xBestIndex: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: *mut sqlite3_index_info, - ) -> ::std::os::raw::c_int, - >, - pub xDisconnect: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xDestroy: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - ppCursor: *mut *mut sqlite3_vtab_cursor, - ) -> ::std::os::raw::c_int, - >, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xFilter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - idxNum: ::std::os::raw::c_int, - idxStr: *const ::std::os::raw::c_char, - argc: ::std::os::raw::c_int, - argv: *mut *mut sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub xNext: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xEof: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - arg2: *mut sqlite3_context, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - pRowid: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xUpdate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - arg4: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xBegin: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xCommit: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xRollback: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xFindFunction: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - nArg: ::std::os::raw::c_int, - zName: *const ::std::os::raw::c_char, - pxFunc: *mut ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - ppArg: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xRename: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - zNew: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!( - ::std::mem::size_of::(), - 160usize, - concat!("Size of: ", stringify!(sqlite3_module)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_module)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xConnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBestIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDisconnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFilter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xEof) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xColumn) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xUpdate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBegin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCommit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollback) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFindFunction) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRename) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info { - pub nConstraint: ::std::os::raw::c_int, - pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, - pub nOrderBy: ::std::os::raw::c_int, - pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, - pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, - pub idxNum: ::std::os::raw::c_int, - pub idxStr: *mut ::std::os::raw::c_char, - pub needToFreeIdxStr: ::std::os::raw::c_int, - pub orderByConsumed: ::std::os::raw::c_int, - pub estimatedCost: f64, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint { - pub iColumn: ::std::os::raw::c_int, - pub op: ::std::os::raw::c_uchar, - pub usable: ::std::os::raw::c_uchar, - pub iTermOffset: ::std::os::raw::c_int, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).op as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(op) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).usable - as *const _ as usize - }, - 5usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(usable) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iTermOffset - as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iTermOffset) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_orderby { - pub iColumn: ::std::os::raw::c_int, - pub desc: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).desc as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(desc) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint_usage { - pub argvIndex: ::std::os::raw::c_int, - pub omit: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).argvIndex - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(argvIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).omit - as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(omit) - ) - ); -} -#[test] -fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nOrderBy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aOrderBy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraintUsage) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxNum) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(needToFreeIdxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(orderByConsumed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedCost as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedCost) - ) - ); -} -extern "C" { - pub fn sqlite3_create_module( - db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - p: *const sqlite3_module, - pClientData: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_module_v2( - db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - p: *const sqlite3_module, - pClientData: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(pModule) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(nRef) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(zErrMsg) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab_cursor { - pub pVtab: *mut sqlite3_vtab, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab_cursor), - "::", - stringify!(pVtab) - ) - ); -} -extern "C" { - pub fn sqlite3_declare_vtab( - arg1: *mut sqlite3, - zSQL: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_overload_function( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob { - _unused: [u8; 0], -} -extern "C" { - pub fn sqlite3_blob_open( - arg1: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - zTable: *const ::std::os::raw::c_char, - zColumn: *const ::std::os::raw::c_char, - iRow: sqlite3_int64, - flags: ::std::os::raw::c_int, - ppBlob: *mut *mut sqlite3_blob, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_blob_read( - arg1: *mut sqlite3_blob, - Z: *mut ::std::os::raw::c_void, - N: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_blob_write( - arg1: *mut sqlite3_blob, - z: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs; -} -extern "C" { - pub fn sqlite3_vfs_register( - arg1: *mut sqlite3_vfs, - makeDflt: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex; -} -extern "C" { - pub fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex); -} -extern "C" { - pub fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex); -} -extern "C" { - pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexNotheld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexInit as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnd) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexAlloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexFree as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexFree) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexTry) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexLeave) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexHeld) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexNotheld) - ) - ); -} -extern "C" { - pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex; -} -extern "C" { - pub fn sqlite3_file_control( - arg1: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - op: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_status( - op: ::std::os::raw::c_int, - pCurrent: *mut ::std::os::raw::c_int, - pHighwater: *mut ::std::os::raw::c_int, - resetFlag: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_db_status( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - pCur: *mut ::std::os::raw::c_int, - pHiwtr: *mut ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_stmt_status( - arg1: *mut sqlite3_stmt, - op: ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods { - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!( - ::std::mem::size_of::(), - 88usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xDestroy) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_backup { - _unused: [u8; 0], -} -extern "C" { - pub fn sqlite3_backup_init( - pDest: *mut sqlite3, - zDestName: *const ::std::os::raw::c_char, - pSource: *mut sqlite3, - zSourceName: *const ::std::os::raw::c_char, - ) -> *mut sqlite3_backup; -} -extern "C" { - pub fn sqlite3_backup_step( - p: *mut sqlite3_backup, - nPage: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_backup_finish(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_backup_remaining(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_backup_pagecount(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_unlock_notify( - pBlocked: *mut sqlite3, - xNotify: ::std::option::Option< - unsafe extern "C" fn( - apArg: *mut *mut ::std::os::raw::c_void, - nArg: ::std::os::raw::c_int, - ), - >, - pNotifyArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_strnicmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_log( - iErrCode: ::std::os::raw::c_int, - zFormat: *const ::std::os::raw::c_char, - ... - ); -} -pub type __builtin_va_list = [__va_list_tag; 1usize]; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct __va_list_tag { - pub gp_offset: ::std::os::raw::c_uint, - pub fp_offset: ::std::os::raw::c_uint, - pub overflow_arg_area: *mut ::std::os::raw::c_void, - pub reg_save_area: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout___va_list_tag() { - assert_eq!( - ::std::mem::size_of::<__va_list_tag>(), - 24usize, - concat!("Size of: ", stringify!(__va_list_tag)) - ); - assert_eq!( - ::std::mem::align_of::<__va_list_tag>(), - 8usize, - concat!("Alignment of ", stringify!(__va_list_tag)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(gp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(fp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(overflow_arg_area) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(reg_save_area) - ) - ); -} -pub const SQLITE_DETERMINISTIC: i32 = 2048; diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7-ext-embed.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7-ext-embed.rs deleted file mode 100644 index d47b88b83..000000000 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7-ext-embed.rs +++ /dev/null @@ -1,7831 +0,0 @@ -/* automatically generated by rust-bindgen */ - -pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 6usize] = b"3.7.7\0"; -pub const SQLITE_VERSION_NUMBER: i32 = 3007007; -pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = - b"2011-06-23 19:49:22 4374b7e83ea0a3fbc3691f9c0c936272862f32f2\0"; -pub const SQLITE_OK: i32 = 0; -pub const SQLITE_ERROR: i32 = 1; -pub const SQLITE_INTERNAL: i32 = 2; -pub const SQLITE_PERM: i32 = 3; -pub const SQLITE_ABORT: i32 = 4; -pub const SQLITE_BUSY: i32 = 5; -pub const SQLITE_LOCKED: i32 = 6; -pub const SQLITE_NOMEM: i32 = 7; -pub const SQLITE_READONLY: i32 = 8; -pub const SQLITE_INTERRUPT: i32 = 9; -pub const SQLITE_IOERR: i32 = 10; -pub const SQLITE_CORRUPT: i32 = 11; -pub const SQLITE_NOTFOUND: i32 = 12; -pub const SQLITE_FULL: i32 = 13; -pub const SQLITE_CANTOPEN: i32 = 14; -pub const SQLITE_PROTOCOL: i32 = 15; -pub const SQLITE_EMPTY: i32 = 16; -pub const SQLITE_SCHEMA: i32 = 17; -pub const SQLITE_TOOBIG: i32 = 18; -pub const SQLITE_CONSTRAINT: i32 = 19; -pub const SQLITE_MISMATCH: i32 = 20; -pub const SQLITE_MISUSE: i32 = 21; -pub const SQLITE_NOLFS: i32 = 22; -pub const SQLITE_AUTH: i32 = 23; -pub const SQLITE_FORMAT: i32 = 24; -pub const SQLITE_RANGE: i32 = 25; -pub const SQLITE_NOTADB: i32 = 26; -pub const SQLITE_ROW: i32 = 100; -pub const SQLITE_DONE: i32 = 101; -pub const SQLITE_IOERR_READ: i32 = 266; -pub const SQLITE_IOERR_SHORT_READ: i32 = 522; -pub const SQLITE_IOERR_WRITE: i32 = 778; -pub const SQLITE_IOERR_FSYNC: i32 = 1034; -pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; -pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; -pub const SQLITE_IOERR_FSTAT: i32 = 1802; -pub const SQLITE_IOERR_UNLOCK: i32 = 2058; -pub const SQLITE_IOERR_RDLOCK: i32 = 2314; -pub const SQLITE_IOERR_DELETE: i32 = 2570; -pub const SQLITE_IOERR_BLOCKED: i32 = 2826; -pub const SQLITE_IOERR_NOMEM: i32 = 3082; -pub const SQLITE_IOERR_ACCESS: i32 = 3338; -pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; -pub const SQLITE_IOERR_LOCK: i32 = 3850; -pub const SQLITE_IOERR_CLOSE: i32 = 4106; -pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; -pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; -pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; -pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; -pub const SQLITE_IOERR_SHMMAP: i32 = 5386; -pub const SQLITE_IOERR_SEEK: i32 = 5642; -pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; -pub const SQLITE_BUSY_RECOVERY: i32 = 261; -pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; -pub const SQLITE_CORRUPT_VTAB: i32 = 267; -pub const SQLITE_READONLY_RECOVERY: i32 = 264; -pub const SQLITE_READONLY_CANTLOCK: i32 = 520; -pub const SQLITE_OPEN_READONLY: i32 = 1; -pub const SQLITE_OPEN_READWRITE: i32 = 2; -pub const SQLITE_OPEN_CREATE: i32 = 4; -pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; -pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; -pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; -pub const SQLITE_OPEN_URI: i32 = 64; -pub const SQLITE_OPEN_MAIN_DB: i32 = 256; -pub const SQLITE_OPEN_TEMP_DB: i32 = 512; -pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; -pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; -pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; -pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; -pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; -pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; -pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; -pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; -pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; -pub const SQLITE_OPEN_WAL: i32 = 524288; -pub const SQLITE_IOCAP_ATOMIC: i32 = 1; -pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; -pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; -pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; -pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; -pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; -pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; -pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; -pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; -pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; -pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; -pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; -pub const SQLITE_LOCK_NONE: i32 = 0; -pub const SQLITE_LOCK_SHARED: i32 = 1; -pub const SQLITE_LOCK_RESERVED: i32 = 2; -pub const SQLITE_LOCK_PENDING: i32 = 3; -pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; -pub const SQLITE_SYNC_NORMAL: i32 = 2; -pub const SQLITE_SYNC_FULL: i32 = 3; -pub const SQLITE_SYNC_DATAONLY: i32 = 16; -pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; -pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_LAST_ERRNO: i32 = 4; -pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; -pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; -pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; -pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; -pub const SQLITE_ACCESS_EXISTS: i32 = 0; -pub const SQLITE_ACCESS_READWRITE: i32 = 1; -pub const SQLITE_ACCESS_READ: i32 = 2; -pub const SQLITE_SHM_UNLOCK: i32 = 1; -pub const SQLITE_SHM_LOCK: i32 = 2; -pub const SQLITE_SHM_SHARED: i32 = 4; -pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; -pub const SQLITE_SHM_NLOCK: i32 = 8; -pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; -pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; -pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; -pub const SQLITE_CONFIG_MALLOC: i32 = 4; -pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; -pub const SQLITE_CONFIG_SCRATCH: i32 = 6; -pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; -pub const SQLITE_CONFIG_HEAP: i32 = 8; -pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; -pub const SQLITE_CONFIG_MUTEX: i32 = 10; -pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; -pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; -pub const SQLITE_CONFIG_PCACHE: i32 = 14; -pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; -pub const SQLITE_CONFIG_LOG: i32 = 16; -pub const SQLITE_CONFIG_URI: i32 = 17; -pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; -pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; -pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; -pub const SQLITE_DENY: i32 = 1; -pub const SQLITE_IGNORE: i32 = 2; -pub const SQLITE_CREATE_INDEX: i32 = 1; -pub const SQLITE_CREATE_TABLE: i32 = 2; -pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; -pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; -pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; -pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; -pub const SQLITE_CREATE_TRIGGER: i32 = 7; -pub const SQLITE_CREATE_VIEW: i32 = 8; -pub const SQLITE_DELETE: i32 = 9; -pub const SQLITE_DROP_INDEX: i32 = 10; -pub const SQLITE_DROP_TABLE: i32 = 11; -pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; -pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; -pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; -pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; -pub const SQLITE_DROP_TRIGGER: i32 = 16; -pub const SQLITE_DROP_VIEW: i32 = 17; -pub const SQLITE_INSERT: i32 = 18; -pub const SQLITE_PRAGMA: i32 = 19; -pub const SQLITE_READ: i32 = 20; -pub const SQLITE_SELECT: i32 = 21; -pub const SQLITE_TRANSACTION: i32 = 22; -pub const SQLITE_UPDATE: i32 = 23; -pub const SQLITE_ATTACH: i32 = 24; -pub const SQLITE_DETACH: i32 = 25; -pub const SQLITE_ALTER_TABLE: i32 = 26; -pub const SQLITE_REINDEX: i32 = 27; -pub const SQLITE_ANALYZE: i32 = 28; -pub const SQLITE_CREATE_VTABLE: i32 = 29; -pub const SQLITE_DROP_VTABLE: i32 = 30; -pub const SQLITE_FUNCTION: i32 = 31; -pub const SQLITE_SAVEPOINT: i32 = 32; -pub const SQLITE_COPY: i32 = 0; -pub const SQLITE_LIMIT_LENGTH: i32 = 0; -pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; -pub const SQLITE_LIMIT_COLUMN: i32 = 2; -pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; -pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; -pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; -pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; -pub const SQLITE_LIMIT_ATTACHED: i32 = 7; -pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; -pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; -pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; -pub const SQLITE_INTEGER: i32 = 1; -pub const SQLITE_FLOAT: i32 = 2; -pub const SQLITE_BLOB: i32 = 4; -pub const SQLITE_NULL: i32 = 5; -pub const SQLITE_TEXT: i32 = 3; -pub const SQLITE3_TEXT: i32 = 3; -pub const SQLITE_UTF8: i32 = 1; -pub const SQLITE_UTF16LE: i32 = 2; -pub const SQLITE_UTF16BE: i32 = 3; -pub const SQLITE_UTF16: i32 = 4; -pub const SQLITE_ANY: i32 = 5; -pub const SQLITE_UTF16_ALIGNED: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; -pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; -pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; -pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; -pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; -pub const SQLITE_MUTEX_FAST: i32 = 0; -pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; -pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; -pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; -pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; -pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; -pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; -pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; -pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; -pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; -pub const SQLITE_TESTCTRL_FIRST: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; -pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; -pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; -pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; -pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; -pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; -pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; -pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; -pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; -pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; -pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; -pub const SQLITE_TESTCTRL_PGHDRSZ: i32 = 17; -pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 18; -pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 19; -pub const SQLITE_TESTCTRL_LAST: i32 = 19; -pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; -pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; -pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; -pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; -pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; -pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; -pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; -pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; -pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; -pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; -pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; -pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; -pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; -pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; -pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; -pub const SQLITE_DBSTATUS_MAX: i32 = 6; -pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; -pub const SQLITE_STMTSTATUS_SORT: i32 = 2; -pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; -pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; -pub const SQLITE_CHECKPOINT_FULL: i32 = 1; -pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; -pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; -pub const SQLITE_ROLLBACK: i32 = 1; -pub const SQLITE_FAIL: i32 = 3; -pub const SQLITE_REPLACE: i32 = 5; -pub type va_list = __builtin_va_list; -pub type __gnuc_va_list = __builtin_va_list; -extern "C" { - #[link_name = "\u{1}sqlite3_version"] - pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3 { - _unused: [u8; 0], -} -pub type sqlite_int64 = ::std::os::raw::c_longlong; -pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; -pub type sqlite3_int64 = sqlite_int64; -pub type sqlite3_uint64 = sqlite_uint64; -pub type sqlite3_callback = ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_file { - pub pMethods: *const sqlite3_io_methods, -} -#[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_file)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_file)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_file), - "::", - stringify!(pMethods) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_io_methods { - pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xRead: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *mut ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xWrite: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *const ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pSize: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xUnlock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCheckReservedLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileControl: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - op: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xSectorSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xDeviceCharacteristics: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xShmMap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iPg: ::std::os::raw::c_int, - pgsz: ::std::os::raw::c_int, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xShmLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - offset: ::std::os::raw::c_int, - n: ::std::os::raw::c_int, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xShmBarrier: ::std::option::Option, - pub xShmUnmap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - deleteFlag: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_io_methods() { - assert_eq!( - ::std::mem::size_of::(), - 136usize, - concat!("Size of: ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xRead) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xWrite) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnlock) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xCheckReservedLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileControl) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSectorSize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ - as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xDeviceCharacteristics) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmMap) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmBarrier) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmUnmap) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex { - _unused: [u8; 0], -} -pub type sqlite3_syscall_ptr = ::std::option::Option; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vfs { - pub iVersion: ::std::os::raw::c_int, - pub szOsFile: ::std::os::raw::c_int, - pub mxPathname: ::std::os::raw::c_int, - pub pNext: *mut sqlite3_vfs, - pub zName: *const ::std::os::raw::c_char, - pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - pOutFlags: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - syncDir: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xAccess: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - flags: ::std::os::raw::c_int, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFullPathname: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - nOut: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xDlOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zFilename: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void, - >, - pub xDlError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zErrMsg: *mut ::std::os::raw::c_char, - ), - >, - pub xDlSym: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ) -> ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ), - >, - >, - pub xDlClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), - >, - pub xRandomness: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSleep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - microseconds: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTime: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, - >, - pub xGetLastError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTimeInt64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xSetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: sqlite3_syscall_ptr, - ) -> ::std::os::raw::c_int, - >, - pub xGetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> sqlite3_syscall_ptr, - >, - pub xNextSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!( - ::std::mem::size_of::(), - 168usize, - concat!("Size of: ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(szOsFile) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(mxPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(zName) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pAppData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xAccess) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xFullPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlSym) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xRandomness) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSleep) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTime) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetLastError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTimeInt64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xNextSystemCall) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xRoundup: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub pAppData: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!( - ::std::mem::size_of::(), - 64usize, - concat!("Size of: ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xMalloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xFree) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRealloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRoundup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(pAppData) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Mem { - _unused: [u8; 0], -} -pub type sqlite3_value = Mem; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_context { - _unused: [u8; 0], -} -pub type sqlite3_destructor_type = - ::std::option::Option; -extern "C" { - #[link_name = "\u{1}sqlite3_temp_directory"] - pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xConnect: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xBestIndex: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: *mut sqlite3_index_info, - ) -> ::std::os::raw::c_int, - >, - pub xDisconnect: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xDestroy: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - ppCursor: *mut *mut sqlite3_vtab_cursor, - ) -> ::std::os::raw::c_int, - >, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xFilter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - idxNum: ::std::os::raw::c_int, - idxStr: *const ::std::os::raw::c_char, - argc: ::std::os::raw::c_int, - argv: *mut *mut sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub xNext: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xEof: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - arg2: *mut sqlite3_context, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - pRowid: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xUpdate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - arg4: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xBegin: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xCommit: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xRollback: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xFindFunction: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - nArg: ::std::os::raw::c_int, - zName: *const ::std::os::raw::c_char, - pxFunc: *mut ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - ppArg: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xRename: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - zNew: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSavepoint: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRelease: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRollbackTo: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!( - ::std::mem::size_of::(), - 184usize, - concat!("Size of: ", stringify!(sqlite3_module)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_module)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xConnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBestIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDisconnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFilter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xEof) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xColumn) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xUpdate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBegin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCommit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollback) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFindFunction) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRename) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSavepoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRelease) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollbackTo) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info { - pub nConstraint: ::std::os::raw::c_int, - pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, - pub nOrderBy: ::std::os::raw::c_int, - pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, - pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, - pub idxNum: ::std::os::raw::c_int, - pub idxStr: *mut ::std::os::raw::c_char, - pub needToFreeIdxStr: ::std::os::raw::c_int, - pub orderByConsumed: ::std::os::raw::c_int, - pub estimatedCost: f64, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint { - pub iColumn: ::std::os::raw::c_int, - pub op: ::std::os::raw::c_uchar, - pub usable: ::std::os::raw::c_uchar, - pub iTermOffset: ::std::os::raw::c_int, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).op as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(op) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).usable - as *const _ as usize - }, - 5usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(usable) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iTermOffset - as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iTermOffset) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_orderby { - pub iColumn: ::std::os::raw::c_int, - pub desc: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).desc as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(desc) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint_usage { - pub argvIndex: ::std::os::raw::c_int, - pub omit: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).argvIndex - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(argvIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).omit - as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(omit) - ) - ); -} -#[test] -fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nOrderBy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aOrderBy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraintUsage) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxNum) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(needToFreeIdxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(orderByConsumed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedCost as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedCost) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(pModule) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(nRef) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(zErrMsg) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab_cursor { - pub pVtab: *mut sqlite3_vtab, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab_cursor), - "::", - stringify!(pVtab) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexNotheld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexInit as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnd) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexAlloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexFree as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexFree) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexTry) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexLeave) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexHeld) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexNotheld) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods { - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!( - ::std::mem::size_of::(), - 88usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xDestroy) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_backup { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_rtree_geometry { - pub pContext: *mut ::std::os::raw::c_void, - pub nParam: ::std::os::raw::c_int, - pub aParam: *mut f64, - pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_rtree_geometry() { - assert_eq!( - ::std::mem::size_of::(), - 40usize, - concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pContext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(nParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(aParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pUser) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(xDelUser) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_api_routines { - pub aggregate_context: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub aggregate_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, - >, - pub bind_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_double: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, - ) -> ::std::os::raw::c_int, - >, - pub bind_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_int64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, - ) -> ::std::os::raw::c_int, - >, - pub bind_null: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub bind_parameter_index: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub bind_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub busy_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub busy_timeout: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub changes: - ::std::option::Option ::std::os::raw::c_int>, - pub close: - ::std::option::Option ::std::os::raw::c_int>, - pub collation_needed: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub collation_needed16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub column_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_bytes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_bytes16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub column_database_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_database_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_decltype: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_decltype16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_double: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, - >, - pub column_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_int64: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, - >, - pub column_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_origin_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_origin_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_table_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_table_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_uchar, - >, - pub column_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_type: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *mut sqlite3_value, - >, - pub commit_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub complete: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, - pub complete16: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub create_collation: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_collation16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_function16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_module: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub data_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub db_handle: - ::std::option::Option *mut sqlite3>, - pub declare_vtab: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub enable_shared_cache: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub errcode: - ::std::option::Option ::std::os::raw::c_int>, - pub errmsg: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, - >, - pub errmsg16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, - >, - pub exec: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub expired: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub finalize: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub free: ::std::option::Option, - pub free_table: - ::std::option::Option, - pub get_autocommit: - ::std::option::Option ::std::os::raw::c_int>, - pub get_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub get_table: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub global_recover: ::std::option::Option ::std::os::raw::c_int>, - pub interruptx: ::std::option::Option, - pub last_insert_rowid: - ::std::option::Option sqlite_int64>, - pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, - pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, - pub malloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub mprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub open16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub prepare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub profile: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub progress_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, - ), - >, - pub realloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub reset: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub result_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_double: - ::std::option::Option, - pub result_error: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_error16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_int64: - ::std::option::Option, - pub result_null: ::std::option::Option, - pub result_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16be: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16le: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_value: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), - >, - pub rollback_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub set_authorizer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub set_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, - ), - >, - pub snprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub step: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub table_column_metadata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub thread_cleanup: ::std::option::Option, - pub total_changes: - ::std::option::Option ::std::os::raw::c_int>, - pub trace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub transfer_bindings: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, - ) -> ::std::os::raw::c_int, - >, - pub update_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub user_data: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, - >, - pub value_blob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_bytes16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_double: ::std::option::Option f64>, - pub value_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_int64: - ::std::option::Option sqlite_int64>, - pub value_numeric_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_text: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, - >, - pub value_text16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16be: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16le: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub vmprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char, - >, - pub overload_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub prepare_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub clear_bindings: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub create_module_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_zeroblob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_close: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, - ) -> ::std::os::raw::c_int, - >, - pub blob_read: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_write: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub create_collation_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub file_control: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub memory_highwater: - ::std::option::Option sqlite3_int64>, - pub memory_used: ::std::option::Option sqlite3_int64>, - pub mutex_alloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub mutex_enter: ::std::option::Option, - pub mutex_free: ::std::option::Option, - pub mutex_leave: ::std::option::Option, - pub mutex_try: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub open_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub release_memory: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub result_error_nomem: ::std::option::Option, - pub result_error_toobig: - ::std::option::Option, - pub sleep: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub soft_heap_limit: ::std::option::Option, - pub vfs_find: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, - >, - pub vfs_register: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub vfs_unregister: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, - >, - pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, - pub result_zeroblob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_error_code: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub test_control: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, - >, - pub randomness: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), - >, - pub context_db_handle: - ::std::option::Option *mut sqlite3>, - pub extended_result_codes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub limit: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub next_stmt: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, - >, - pub sql: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, - >, - pub status: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub backup_finish: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_init: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut sqlite3, - arg4: *const ::std::os::raw::c_char, - ) -> *mut sqlite3_backup, - >, - pub backup_pagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_remaining: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_step: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_backup, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub compileoption_get: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, - >, - pub compileoption_used: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, - pub create_function_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub db_config: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int, - >, - pub db_mutex: - ::std::option::Option *mut sqlite3_mutex>, - pub db_status: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub extended_errcode: - ::std::option::Option ::std::os::raw::c_int>, - pub log: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char, ...), - >, - pub soft_heap_limit64: - ::std::option::Option sqlite3_int64>, - pub sourceid: ::std::option::Option *const ::std::os::raw::c_char>, - pub stmt_status: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub strnicmp: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub unlock_notify: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub wal_autocheckpoint: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub wal_checkpoint: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub wal_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_api_routines() { - assert_eq!( - ::std::mem::size_of::(), - 1408usize, - concat!("Size of: ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_context as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_context) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_count as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_double as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_count as *const _ - as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_index as *const _ - as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_index) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_name as *const _ - as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_text16 as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_handler as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_handler) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_timeout as *const _ as usize - }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_timeout) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(close) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed as *const _ as usize - }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_blob as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes as *const _ as usize - }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize - }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_count as *const _ as usize - }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name as *const _ - as usize - }, - 184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name16 as *const _ - as usize - }, - 192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype as *const _ as usize - }, - 200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize - }, - 208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_double as *const _ as usize - }, - 216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, - 224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_int64 as *const _ as usize - }, - 232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name as *const _ as usize - }, - 240usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name16 as *const _ as usize - }, - 248usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name as *const _ as usize - }, - 256usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name16 as *const _ - as usize - }, - 264usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name as *const _ as usize - }, - 272usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name16 as *const _ - as usize - }, - 280usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text as *const _ as usize - }, - 288usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text16 as *const _ as usize - }, - 296usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_type as *const _ as usize - }, - 304usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_type) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_value as *const _ as usize - }, - 312usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).commit_hook as *const _ as usize - }, - 320usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(commit_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, - 328usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, - 336usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation as *const _ as usize - }, - 344usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation16 as *const _ as usize - }, - 352usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function as *const _ as usize - }, - 360usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function16 as *const _ as usize - }, - 368usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module as *const _ as usize - }, - 376usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, - 384usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(data_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, - 392usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).declare_vtab as *const _ as usize - }, - 400usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(declare_vtab) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).enable_shared_cache as *const _ - as usize - }, - 408usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(enable_shared_cache) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, - 416usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, - 424usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, - 432usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, - 440usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(exec) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, - 448usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(expired) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, - 456usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(finalize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, - 464usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, - 472usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_autocommit as *const _ as usize - }, - 480usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_autocommit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_auxdata as *const _ as usize - }, - 488usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, - 496usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).global_recover as *const _ as usize - }, - 504usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(global_recover) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, - 512usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(interruptx) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize - }, - 520usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(last_insert_rowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, - 528usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).libversion_number as *const _ as usize - }, - 536usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion_number) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, - 544usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(malloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, - 552usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, - 560usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, - 568usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, - 576usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, - 584usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, - 592usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(profile) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).progress_handler as *const _ as usize - }, - 600usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(progress_handler) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, - 608usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(realloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, - 616usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(reset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_blob as *const _ as usize - }, - 624usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_double as *const _ as usize - }, - 632usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_double) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error as *const _ as usize - }, - 640usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error16 as *const _ as usize - }, - 648usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, - 656usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_int64 as *const _ as usize - }, - 664usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_null as *const _ as usize - }, - 672usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text as *const _ as usize - }, - 680usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16 as *const _ as usize - }, - 688usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16be as *const _ as usize - }, - 696usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16le as *const _ as usize - }, - 704usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16le) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_value as *const _ as usize - }, - 712usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rollback_hook as *const _ as usize - }, - 720usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(rollback_hook) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_authorizer as *const _ as usize - }, - 728usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_authorizer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_auxdata as *const _ as usize - }, - 736usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).snprintf as *const _ as usize }, - 744usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(snprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, - 752usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(step) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).table_column_metadata as *const _ - as usize - }, - 760usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(table_column_metadata) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize - }, - 768usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(thread_cleanup) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).total_changes as *const _ as usize - }, - 776usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(total_changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, - 784usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(trace) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize - }, - 792usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(transfer_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).update_hook as *const _ as usize - }, - 800usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(update_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, - 808usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(user_data) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, - 816usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes as *const _ as usize - }, - 824usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize - }, - 832usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_double as *const _ as usize - }, - 840usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, - 848usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_int64 as *const _ as usize - }, - 856usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize - }, - 864usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_numeric_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, - 872usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16 as *const _ as usize - }, - 880usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16be as *const _ as usize - }, - 888usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16le as *const _ as usize - }, - 896usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16le) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, - 904usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, - 912usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vmprintf) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).overload_function as *const _ as usize - }, - 920usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(overload_function) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, - 928usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize - }, - 936usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).clear_bindings as *const _ as usize - }, - 944usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(clear_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize - }, - 952usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize - }, - 960usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_zeroblob) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, - 968usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_bytes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, - 976usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_close) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, - 984usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, - 992usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_read) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, - 1000usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_write) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation_v2 as *const _ - as usize - }, - 1008usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).file_control as *const _ as usize - }, - 1016usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(file_control) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_highwater as *const _ as usize - }, - 1024usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_highwater) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_used as *const _ as usize - }, - 1032usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_used) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize - }, - 1040usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_alloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_enter as *const _ as usize - }, - 1048usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_enter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, - 1056usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_free) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_leave as *const _ as usize - }, - 1064usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_leave) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, - 1072usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_try) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, - 1080usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).release_memory as *const _ as usize - }, - 1088usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(release_memory) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize - }, - 1096usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_nomem) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_toobig as *const _ - as usize - }, - 1104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_toobig) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, - 1112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sleep) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize - }, - 1120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(soft_heap_limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, - 1128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_find) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_register as *const _ as usize - }, - 1136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_register) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize - }, - 1144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_unregister) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize - }, - 1152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(xthreadsafe) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize - }, - 1160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_zeroblob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_code as *const _ as usize - }, - 1168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_code) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).test_control as *const _ as usize - }, - 1176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(test_control) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, - 1184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(randomness) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).context_db_handle as *const _ as usize - }, - 1192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(context_db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).extended_result_codes as *const _ - as usize - }, - 1200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(extended_result_codes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, - 1208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, - 1216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(next_stmt) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, - 1224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sql) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, - 1232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(status) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_finish as *const _ as usize - }, - 1240usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_finish) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_init as *const _ as usize - }, - 1248usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_init) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_pagecount as *const _ as usize - }, - 1256usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_pagecount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_remaining as *const _ as usize - }, - 1264usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_remaining) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_step as *const _ as usize - }, - 1272usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_step) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).compileoption_get as *const _ as usize - }, - 1280usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(compileoption_get) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).compileoption_used as *const _ as usize - }, - 1288usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(compileoption_used) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function_v2 as *const _ as usize - }, - 1296usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function_v2) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_config as *const _ as usize }, - 1304usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_config) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_mutex as *const _ as usize }, - 1312usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_mutex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_status as *const _ as usize }, - 1320usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_status) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).extended_errcode as *const _ as usize - }, - 1328usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(extended_errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).log as *const _ as usize }, - 1336usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(log) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).soft_heap_limit64 as *const _ as usize - }, - 1344usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(soft_heap_limit64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sourceid as *const _ as usize }, - 1352usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sourceid) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stmt_status as *const _ as usize - }, - 1360usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_status) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).strnicmp as *const _ as usize }, - 1368usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(strnicmp) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).unlock_notify as *const _ as usize - }, - 1376usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(unlock_notify) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_autocheckpoint as *const _ as usize - }, - 1384usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_autocheckpoint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_checkpoint as *const _ as usize - }, - 1392usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_checkpoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).wal_hook as *const _ as usize }, - 1400usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_hook) - ) - ); -} -pub type __builtin_va_list = [__va_list_tag; 1usize]; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct __va_list_tag { - pub gp_offset: ::std::os::raw::c_uint, - pub fp_offset: ::std::os::raw::c_uint, - pub overflow_arg_area: *mut ::std::os::raw::c_void, - pub reg_save_area: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout___va_list_tag() { - assert_eq!( - ::std::mem::size_of::<__va_list_tag>(), - 24usize, - concat!("Size of: ", stringify!(__va_list_tag)) - ); - assert_eq!( - ::std::mem::align_of::<__va_list_tag>(), - 8usize, - concat!("Alignment of ", stringify!(__va_list_tag)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(gp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(fp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(overflow_arg_area) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(reg_save_area) - ) - ); -} - -// bindings were built with loadable_extension_embedded: -// define sqlite3_api as an extern since this code will be embedded -// within a loadable extension that defines and exports this itself -extern "C" { - #[no_mangle] - pub static mut sqlite3_api: *mut sqlite3_api_routines; -} - -// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) - -pub unsafe fn sqlite3_aggregate_context( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_context.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_context", - " function" - )))(arg1, nBytes) -} - -pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_blob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_blob", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_double( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_double", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_null( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_null", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_parameter_index( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_index.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_index", - " function" - )))(arg1, zName) -} - -pub unsafe fn sqlite3_bind_parameter_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_text( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_text16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_bind_value( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_value", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_handler( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_handler", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_timeout( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_timeout.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_timeout", - " function" - )))(arg1, ms) -} - -pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_collation_needed( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_collation_needed16( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_column_blob( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_blob", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_column_database_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_database_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_decltype( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype", - " function" - )))(arg1, i) -} - -pub unsafe fn sqlite3_column_decltype16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_double", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int64( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int64", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_text( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_text16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_type( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_type", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_value( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_value", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_commit_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).commit_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "commit_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete16", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_create_collation( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_collation16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_function( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_function16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function16", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_module( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).data_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "data_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_declare_vtab( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).declare_vtab.expect(stringify!( - "sqlite3_api contains null pointer for ", - "declare_vtab", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).enable_shared_cache.expect(stringify!( - "sqlite3_api contains null pointer for ", - "enable_shared_cache", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errcode", - " function" - )))(db) -} - -pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_exec( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).exec.expect(stringify!( - "sqlite3_api contains null pointer for ", - "exec", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).expired.expect(stringify!( - "sqlite3_api contains null pointer for ", - "expired", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).finalize.expect(stringify!( - "sqlite3_api contains null pointer for ", - "finalize", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free_table", - " function" - )))(result) -} - -pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_autocommit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_autocommit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_get_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_auxdata", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_get_table( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_table", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).global_recover.expect(stringify!( - "sqlite3_api contains null pointer for ", - "global_recover", - " function" - )))() -} - -pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).interruptx.expect(stringify!( - "sqlite3_api contains null pointer for ", - "interruptx", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).last_insert_rowid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "last_insert_rowid", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion", - " function" - )))() -} - -pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion_number.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion_number", - " function" - )))() -} - -pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).malloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "malloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mprintf( - arg1: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mprintf", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_open( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_open16( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_prepare( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_profile( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).profile.expect(stringify!( - "sqlite3_api contains null pointer for ", - "profile", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_progress_handler( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).progress_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "progress_handler", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_realloc( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).realloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "realloc", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).reset.expect(stringify!( - "sqlite3_api contains null pointer for ", - "reset", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_result_blob( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_blob", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_double", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_error16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_null", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_text( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16be( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16be", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16le( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16le", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_value", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_rollback_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).rollback_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "rollback_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_authorizer( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_authorizer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_authorizer", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_auxdata", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_snprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).snprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "snprintf", - " function" - )))(arg1, arg2, arg3, vararg1) -} - -pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).step.expect(stringify!( - "sqlite3_api contains null pointer for ", - "step", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_table_column_metadata( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).table_column_metadata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "table_column_metadata", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) -} - -pub unsafe fn sqlite3_thread_cleanup() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).thread_cleanup.expect(stringify!( - "sqlite3_api contains null pointer for ", - "thread_cleanup", - " function" - )))() -} - -pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).total_changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "total_changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_trace( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).trace.expect(stringify!( - "sqlite3_api contains null pointer for ", - "trace", - " function" - )))(arg1, xTrace, arg2) -} - -pub unsafe fn sqlite3_transfer_bindings( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).transfer_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "transfer_bindings", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_update_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).update_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "update_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).user_data.expect(stringify!( - "sqlite3_api contains null pointer for ", - "user_data", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_blob", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_double", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_numeric_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_numeric_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16be", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16le", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vmprintf( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vmprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vmprintf", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_overload_function( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).overload_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "overload_function", - " function" - )))(arg1, zFuncName, nArg) -} - -pub unsafe fn sqlite3_prepare_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).clear_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "clear_bindings", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_module_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module_v2", - " function" - )))(arg1, arg2, arg3, arg4, xDestroy) -} - -pub unsafe fn sqlite3_bind_zeroblob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_zeroblob", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_open( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_open", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) -} - -pub unsafe fn sqlite3_blob_read( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_read.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_read", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_blob_write( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_write.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_write", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_create_collation_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_file_control( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).file_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "file_control", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_highwater.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_highwater", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_used.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_used", - " function" - )))() -} - -pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_alloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_alloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_enter.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_enter", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_leave.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_leave", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_try.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_try", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_open_v2( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open_v2", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).release_memory.expect(stringify!( - "sqlite3_api contains null pointer for ", - "release_memory", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_nomem.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_nomem", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_toobig.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_toobig", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sleep.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sleep", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).soft_heap_limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "soft_heap_limit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_find.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_find", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_register( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_register.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_register", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_unregister.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_unregister", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).xthreadsafe.expect(stringify!( - "sqlite3_api contains null pointer for ", - "xthreadsafe", - " function" - )))() -} - -pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_zeroblob", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_code.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_code", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_test_control( - arg1: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).test_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "test_control", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).randomness.expect(stringify!( - "sqlite3_api contains null pointer for ", - "randomness", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).context_db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "context_db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_extended_result_codes( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).extended_result_codes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "extended_result_codes", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_limit( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "limit", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).next_stmt.expect(stringify!( - "sqlite3_api contains null pointer for ", - "next_stmt", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sql.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sql", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_status( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "status", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_finish.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_finish", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_init( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut sqlite3, - arg4: *const ::std::os::raw::c_char, -) -> *mut sqlite3_backup { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_init.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_init", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_pagecount.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_pagecount", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_remaining.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_remaining", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_step( - arg1: *mut sqlite3_backup, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_step.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_step", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_compileoption_get( - arg1: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).compileoption_get.expect(stringify!( - "sqlite3_api contains null pointer for ", - "compileoption_get", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_compileoption_used( - arg1: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).compileoption_used.expect(stringify!( - "sqlite3_api contains null pointer for ", - "compileoption_used", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_function_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal, xDestroy) -} - -pub unsafe fn sqlite3_db_config( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, - vararg2: &mut i32, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_config.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_config", - " function" - )))(arg1, arg2, vararg1, vararg2) -} - -pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_mutex.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_mutex", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_db_status( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_status", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).extended_errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "extended_errcode", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_log( - arg1: ::std::os::raw::c_int, - arg2: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).log.expect(stringify!( - "sqlite3_api contains null pointer for ", - "log", - " function" - )))(arg1, arg2, vararg1) -} - -pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).soft_heap_limit64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "soft_heap_limit64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sourceid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sourceid", - " function" - )))() -} - -pub unsafe fn sqlite3_stmt_status( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_status", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_strnicmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).strnicmp.expect(stringify!( - "sqlite3_api contains null pointer for ", - "strnicmp", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_unlock_notify( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int), - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).unlock_notify.expect(stringify!( - "sqlite3_api contains null pointer for ", - "unlock_notify", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_wal_autocheckpoint( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_autocheckpoint", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_wal_checkpoint( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_checkpoint.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_checkpoint", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_wal_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub const SQLITE_DETERMINISTIC: i32 = 2048; diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7-ext.rs deleted file mode 100644 index 2e44d421e..000000000 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7-ext.rs +++ /dev/null @@ -1,7829 +0,0 @@ -/* automatically generated by rust-bindgen */ - -pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 6usize] = b"3.7.7\0"; -pub const SQLITE_VERSION_NUMBER: i32 = 3007007; -pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = - b"2011-06-23 19:49:22 4374b7e83ea0a3fbc3691f9c0c936272862f32f2\0"; -pub const SQLITE_OK: i32 = 0; -pub const SQLITE_ERROR: i32 = 1; -pub const SQLITE_INTERNAL: i32 = 2; -pub const SQLITE_PERM: i32 = 3; -pub const SQLITE_ABORT: i32 = 4; -pub const SQLITE_BUSY: i32 = 5; -pub const SQLITE_LOCKED: i32 = 6; -pub const SQLITE_NOMEM: i32 = 7; -pub const SQLITE_READONLY: i32 = 8; -pub const SQLITE_INTERRUPT: i32 = 9; -pub const SQLITE_IOERR: i32 = 10; -pub const SQLITE_CORRUPT: i32 = 11; -pub const SQLITE_NOTFOUND: i32 = 12; -pub const SQLITE_FULL: i32 = 13; -pub const SQLITE_CANTOPEN: i32 = 14; -pub const SQLITE_PROTOCOL: i32 = 15; -pub const SQLITE_EMPTY: i32 = 16; -pub const SQLITE_SCHEMA: i32 = 17; -pub const SQLITE_TOOBIG: i32 = 18; -pub const SQLITE_CONSTRAINT: i32 = 19; -pub const SQLITE_MISMATCH: i32 = 20; -pub const SQLITE_MISUSE: i32 = 21; -pub const SQLITE_NOLFS: i32 = 22; -pub const SQLITE_AUTH: i32 = 23; -pub const SQLITE_FORMAT: i32 = 24; -pub const SQLITE_RANGE: i32 = 25; -pub const SQLITE_NOTADB: i32 = 26; -pub const SQLITE_ROW: i32 = 100; -pub const SQLITE_DONE: i32 = 101; -pub const SQLITE_IOERR_READ: i32 = 266; -pub const SQLITE_IOERR_SHORT_READ: i32 = 522; -pub const SQLITE_IOERR_WRITE: i32 = 778; -pub const SQLITE_IOERR_FSYNC: i32 = 1034; -pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; -pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; -pub const SQLITE_IOERR_FSTAT: i32 = 1802; -pub const SQLITE_IOERR_UNLOCK: i32 = 2058; -pub const SQLITE_IOERR_RDLOCK: i32 = 2314; -pub const SQLITE_IOERR_DELETE: i32 = 2570; -pub const SQLITE_IOERR_BLOCKED: i32 = 2826; -pub const SQLITE_IOERR_NOMEM: i32 = 3082; -pub const SQLITE_IOERR_ACCESS: i32 = 3338; -pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; -pub const SQLITE_IOERR_LOCK: i32 = 3850; -pub const SQLITE_IOERR_CLOSE: i32 = 4106; -pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; -pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; -pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; -pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; -pub const SQLITE_IOERR_SHMMAP: i32 = 5386; -pub const SQLITE_IOERR_SEEK: i32 = 5642; -pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; -pub const SQLITE_BUSY_RECOVERY: i32 = 261; -pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; -pub const SQLITE_CORRUPT_VTAB: i32 = 267; -pub const SQLITE_READONLY_RECOVERY: i32 = 264; -pub const SQLITE_READONLY_CANTLOCK: i32 = 520; -pub const SQLITE_OPEN_READONLY: i32 = 1; -pub const SQLITE_OPEN_READWRITE: i32 = 2; -pub const SQLITE_OPEN_CREATE: i32 = 4; -pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; -pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; -pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; -pub const SQLITE_OPEN_URI: i32 = 64; -pub const SQLITE_OPEN_MAIN_DB: i32 = 256; -pub const SQLITE_OPEN_TEMP_DB: i32 = 512; -pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; -pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; -pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; -pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; -pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; -pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; -pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; -pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; -pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; -pub const SQLITE_OPEN_WAL: i32 = 524288; -pub const SQLITE_IOCAP_ATOMIC: i32 = 1; -pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; -pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; -pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; -pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; -pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; -pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; -pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; -pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; -pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; -pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; -pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; -pub const SQLITE_LOCK_NONE: i32 = 0; -pub const SQLITE_LOCK_SHARED: i32 = 1; -pub const SQLITE_LOCK_RESERVED: i32 = 2; -pub const SQLITE_LOCK_PENDING: i32 = 3; -pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; -pub const SQLITE_SYNC_NORMAL: i32 = 2; -pub const SQLITE_SYNC_FULL: i32 = 3; -pub const SQLITE_SYNC_DATAONLY: i32 = 16; -pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; -pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_LAST_ERRNO: i32 = 4; -pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; -pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; -pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; -pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; -pub const SQLITE_ACCESS_EXISTS: i32 = 0; -pub const SQLITE_ACCESS_READWRITE: i32 = 1; -pub const SQLITE_ACCESS_READ: i32 = 2; -pub const SQLITE_SHM_UNLOCK: i32 = 1; -pub const SQLITE_SHM_LOCK: i32 = 2; -pub const SQLITE_SHM_SHARED: i32 = 4; -pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; -pub const SQLITE_SHM_NLOCK: i32 = 8; -pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; -pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; -pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; -pub const SQLITE_CONFIG_MALLOC: i32 = 4; -pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; -pub const SQLITE_CONFIG_SCRATCH: i32 = 6; -pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; -pub const SQLITE_CONFIG_HEAP: i32 = 8; -pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; -pub const SQLITE_CONFIG_MUTEX: i32 = 10; -pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; -pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; -pub const SQLITE_CONFIG_PCACHE: i32 = 14; -pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; -pub const SQLITE_CONFIG_LOG: i32 = 16; -pub const SQLITE_CONFIG_URI: i32 = 17; -pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; -pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; -pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; -pub const SQLITE_DENY: i32 = 1; -pub const SQLITE_IGNORE: i32 = 2; -pub const SQLITE_CREATE_INDEX: i32 = 1; -pub const SQLITE_CREATE_TABLE: i32 = 2; -pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; -pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; -pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; -pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; -pub const SQLITE_CREATE_TRIGGER: i32 = 7; -pub const SQLITE_CREATE_VIEW: i32 = 8; -pub const SQLITE_DELETE: i32 = 9; -pub const SQLITE_DROP_INDEX: i32 = 10; -pub const SQLITE_DROP_TABLE: i32 = 11; -pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; -pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; -pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; -pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; -pub const SQLITE_DROP_TRIGGER: i32 = 16; -pub const SQLITE_DROP_VIEW: i32 = 17; -pub const SQLITE_INSERT: i32 = 18; -pub const SQLITE_PRAGMA: i32 = 19; -pub const SQLITE_READ: i32 = 20; -pub const SQLITE_SELECT: i32 = 21; -pub const SQLITE_TRANSACTION: i32 = 22; -pub const SQLITE_UPDATE: i32 = 23; -pub const SQLITE_ATTACH: i32 = 24; -pub const SQLITE_DETACH: i32 = 25; -pub const SQLITE_ALTER_TABLE: i32 = 26; -pub const SQLITE_REINDEX: i32 = 27; -pub const SQLITE_ANALYZE: i32 = 28; -pub const SQLITE_CREATE_VTABLE: i32 = 29; -pub const SQLITE_DROP_VTABLE: i32 = 30; -pub const SQLITE_FUNCTION: i32 = 31; -pub const SQLITE_SAVEPOINT: i32 = 32; -pub const SQLITE_COPY: i32 = 0; -pub const SQLITE_LIMIT_LENGTH: i32 = 0; -pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; -pub const SQLITE_LIMIT_COLUMN: i32 = 2; -pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; -pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; -pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; -pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; -pub const SQLITE_LIMIT_ATTACHED: i32 = 7; -pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; -pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; -pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; -pub const SQLITE_INTEGER: i32 = 1; -pub const SQLITE_FLOAT: i32 = 2; -pub const SQLITE_BLOB: i32 = 4; -pub const SQLITE_NULL: i32 = 5; -pub const SQLITE_TEXT: i32 = 3; -pub const SQLITE3_TEXT: i32 = 3; -pub const SQLITE_UTF8: i32 = 1; -pub const SQLITE_UTF16LE: i32 = 2; -pub const SQLITE_UTF16BE: i32 = 3; -pub const SQLITE_UTF16: i32 = 4; -pub const SQLITE_ANY: i32 = 5; -pub const SQLITE_UTF16_ALIGNED: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; -pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; -pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; -pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; -pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; -pub const SQLITE_MUTEX_FAST: i32 = 0; -pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; -pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; -pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; -pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; -pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; -pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; -pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; -pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; -pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; -pub const SQLITE_TESTCTRL_FIRST: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; -pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; -pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; -pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; -pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; -pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; -pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; -pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; -pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; -pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; -pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; -pub const SQLITE_TESTCTRL_PGHDRSZ: i32 = 17; -pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 18; -pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 19; -pub const SQLITE_TESTCTRL_LAST: i32 = 19; -pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; -pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; -pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; -pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; -pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; -pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; -pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; -pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; -pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; -pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; -pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; -pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; -pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; -pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; -pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; -pub const SQLITE_DBSTATUS_MAX: i32 = 6; -pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; -pub const SQLITE_STMTSTATUS_SORT: i32 = 2; -pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; -pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; -pub const SQLITE_CHECKPOINT_FULL: i32 = 1; -pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; -pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; -pub const SQLITE_ROLLBACK: i32 = 1; -pub const SQLITE_FAIL: i32 = 3; -pub const SQLITE_REPLACE: i32 = 5; -pub type va_list = __builtin_va_list; -pub type __gnuc_va_list = __builtin_va_list; -extern "C" { - #[link_name = "\u{1}sqlite3_version"] - pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3 { - _unused: [u8; 0], -} -pub type sqlite_int64 = ::std::os::raw::c_longlong; -pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; -pub type sqlite3_int64 = sqlite_int64; -pub type sqlite3_uint64 = sqlite_uint64; -pub type sqlite3_callback = ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_file { - pub pMethods: *const sqlite3_io_methods, -} -#[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_file)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_file)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_file), - "::", - stringify!(pMethods) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_io_methods { - pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xRead: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *mut ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xWrite: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *const ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pSize: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xUnlock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCheckReservedLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileControl: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - op: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xSectorSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xDeviceCharacteristics: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xShmMap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iPg: ::std::os::raw::c_int, - pgsz: ::std::os::raw::c_int, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xShmLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - offset: ::std::os::raw::c_int, - n: ::std::os::raw::c_int, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xShmBarrier: ::std::option::Option, - pub xShmUnmap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - deleteFlag: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_io_methods() { - assert_eq!( - ::std::mem::size_of::(), - 136usize, - concat!("Size of: ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xRead) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xWrite) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnlock) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xCheckReservedLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileControl) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSectorSize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ - as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xDeviceCharacteristics) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmMap) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmBarrier) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmUnmap) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex { - _unused: [u8; 0], -} -pub type sqlite3_syscall_ptr = ::std::option::Option; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vfs { - pub iVersion: ::std::os::raw::c_int, - pub szOsFile: ::std::os::raw::c_int, - pub mxPathname: ::std::os::raw::c_int, - pub pNext: *mut sqlite3_vfs, - pub zName: *const ::std::os::raw::c_char, - pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - pOutFlags: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - syncDir: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xAccess: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - flags: ::std::os::raw::c_int, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFullPathname: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - nOut: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xDlOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zFilename: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void, - >, - pub xDlError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zErrMsg: *mut ::std::os::raw::c_char, - ), - >, - pub xDlSym: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ) -> ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ), - >, - >, - pub xDlClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), - >, - pub xRandomness: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSleep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - microseconds: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTime: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, - >, - pub xGetLastError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTimeInt64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xSetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: sqlite3_syscall_ptr, - ) -> ::std::os::raw::c_int, - >, - pub xGetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> sqlite3_syscall_ptr, - >, - pub xNextSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!( - ::std::mem::size_of::(), - 168usize, - concat!("Size of: ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(szOsFile) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(mxPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(zName) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pAppData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xAccess) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xFullPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlSym) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xRandomness) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSleep) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTime) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetLastError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTimeInt64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xNextSystemCall) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xRoundup: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub pAppData: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!( - ::std::mem::size_of::(), - 64usize, - concat!("Size of: ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xMalloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xFree) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRealloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRoundup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(pAppData) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Mem { - _unused: [u8; 0], -} -pub type sqlite3_value = Mem; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_context { - _unused: [u8; 0], -} -pub type sqlite3_destructor_type = - ::std::option::Option; -extern "C" { - #[link_name = "\u{1}sqlite3_temp_directory"] - pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xConnect: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xBestIndex: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: *mut sqlite3_index_info, - ) -> ::std::os::raw::c_int, - >, - pub xDisconnect: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xDestroy: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - ppCursor: *mut *mut sqlite3_vtab_cursor, - ) -> ::std::os::raw::c_int, - >, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xFilter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - idxNum: ::std::os::raw::c_int, - idxStr: *const ::std::os::raw::c_char, - argc: ::std::os::raw::c_int, - argv: *mut *mut sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub xNext: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xEof: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - arg2: *mut sqlite3_context, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - pRowid: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xUpdate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - arg4: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xBegin: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xCommit: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xRollback: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xFindFunction: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - nArg: ::std::os::raw::c_int, - zName: *const ::std::os::raw::c_char, - pxFunc: *mut ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - ppArg: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xRename: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - zNew: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSavepoint: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRelease: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRollbackTo: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!( - ::std::mem::size_of::(), - 184usize, - concat!("Size of: ", stringify!(sqlite3_module)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_module)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xConnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBestIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDisconnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFilter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xEof) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xColumn) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xUpdate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBegin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCommit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollback) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFindFunction) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRename) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSavepoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRelease) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollbackTo) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info { - pub nConstraint: ::std::os::raw::c_int, - pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, - pub nOrderBy: ::std::os::raw::c_int, - pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, - pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, - pub idxNum: ::std::os::raw::c_int, - pub idxStr: *mut ::std::os::raw::c_char, - pub needToFreeIdxStr: ::std::os::raw::c_int, - pub orderByConsumed: ::std::os::raw::c_int, - pub estimatedCost: f64, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint { - pub iColumn: ::std::os::raw::c_int, - pub op: ::std::os::raw::c_uchar, - pub usable: ::std::os::raw::c_uchar, - pub iTermOffset: ::std::os::raw::c_int, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).op as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(op) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).usable - as *const _ as usize - }, - 5usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(usable) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iTermOffset - as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iTermOffset) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_orderby { - pub iColumn: ::std::os::raw::c_int, - pub desc: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).desc as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(desc) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint_usage { - pub argvIndex: ::std::os::raw::c_int, - pub omit: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).argvIndex - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(argvIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).omit - as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(omit) - ) - ); -} -#[test] -fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nOrderBy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aOrderBy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraintUsage) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxNum) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(needToFreeIdxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(orderByConsumed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedCost as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedCost) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(pModule) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(nRef) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(zErrMsg) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab_cursor { - pub pVtab: *mut sqlite3_vtab, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab_cursor), - "::", - stringify!(pVtab) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexNotheld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexInit as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnd) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexAlloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexFree as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexFree) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexTry) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexLeave) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexHeld) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexNotheld) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods { - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!( - ::std::mem::size_of::(), - 88usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xDestroy) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_backup { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_rtree_geometry { - pub pContext: *mut ::std::os::raw::c_void, - pub nParam: ::std::os::raw::c_int, - pub aParam: *mut f64, - pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_rtree_geometry() { - assert_eq!( - ::std::mem::size_of::(), - 40usize, - concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pContext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(nParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(aParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pUser) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(xDelUser) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_api_routines { - pub aggregate_context: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub aggregate_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, - >, - pub bind_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_double: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, - ) -> ::std::os::raw::c_int, - >, - pub bind_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_int64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, - ) -> ::std::os::raw::c_int, - >, - pub bind_null: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub bind_parameter_index: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub bind_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub busy_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub busy_timeout: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub changes: - ::std::option::Option ::std::os::raw::c_int>, - pub close: - ::std::option::Option ::std::os::raw::c_int>, - pub collation_needed: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub collation_needed16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub column_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_bytes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_bytes16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub column_database_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_database_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_decltype: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_decltype16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_double: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, - >, - pub column_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_int64: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, - >, - pub column_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_origin_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_origin_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_table_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_table_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_uchar, - >, - pub column_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_type: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *mut sqlite3_value, - >, - pub commit_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub complete: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, - pub complete16: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub create_collation: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_collation16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_function16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_module: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub data_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub db_handle: - ::std::option::Option *mut sqlite3>, - pub declare_vtab: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub enable_shared_cache: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub errcode: - ::std::option::Option ::std::os::raw::c_int>, - pub errmsg: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, - >, - pub errmsg16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, - >, - pub exec: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub expired: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub finalize: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub free: ::std::option::Option, - pub free_table: - ::std::option::Option, - pub get_autocommit: - ::std::option::Option ::std::os::raw::c_int>, - pub get_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub get_table: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub global_recover: ::std::option::Option ::std::os::raw::c_int>, - pub interruptx: ::std::option::Option, - pub last_insert_rowid: - ::std::option::Option sqlite_int64>, - pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, - pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, - pub malloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub mprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub open16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub prepare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub profile: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub progress_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, - ), - >, - pub realloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub reset: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub result_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_double: - ::std::option::Option, - pub result_error: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_error16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_int64: - ::std::option::Option, - pub result_null: ::std::option::Option, - pub result_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16be: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16le: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_value: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), - >, - pub rollback_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub set_authorizer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub set_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, - ), - >, - pub snprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub step: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub table_column_metadata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub thread_cleanup: ::std::option::Option, - pub total_changes: - ::std::option::Option ::std::os::raw::c_int>, - pub trace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub transfer_bindings: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, - ) -> ::std::os::raw::c_int, - >, - pub update_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub user_data: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, - >, - pub value_blob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_bytes16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_double: ::std::option::Option f64>, - pub value_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_int64: - ::std::option::Option sqlite_int64>, - pub value_numeric_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_text: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, - >, - pub value_text16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16be: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16le: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub vmprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char, - >, - pub overload_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub prepare_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub clear_bindings: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub create_module_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_zeroblob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_close: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, - ) -> ::std::os::raw::c_int, - >, - pub blob_read: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_write: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub create_collation_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub file_control: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub memory_highwater: - ::std::option::Option sqlite3_int64>, - pub memory_used: ::std::option::Option sqlite3_int64>, - pub mutex_alloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub mutex_enter: ::std::option::Option, - pub mutex_free: ::std::option::Option, - pub mutex_leave: ::std::option::Option, - pub mutex_try: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub open_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub release_memory: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub result_error_nomem: ::std::option::Option, - pub result_error_toobig: - ::std::option::Option, - pub sleep: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub soft_heap_limit: ::std::option::Option, - pub vfs_find: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, - >, - pub vfs_register: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub vfs_unregister: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, - >, - pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, - pub result_zeroblob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_error_code: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub test_control: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, - >, - pub randomness: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), - >, - pub context_db_handle: - ::std::option::Option *mut sqlite3>, - pub extended_result_codes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub limit: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub next_stmt: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, - >, - pub sql: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, - >, - pub status: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub backup_finish: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_init: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut sqlite3, - arg4: *const ::std::os::raw::c_char, - ) -> *mut sqlite3_backup, - >, - pub backup_pagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_remaining: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_step: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_backup, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub compileoption_get: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, - >, - pub compileoption_used: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, - pub create_function_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub db_config: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int, - >, - pub db_mutex: - ::std::option::Option *mut sqlite3_mutex>, - pub db_status: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub extended_errcode: - ::std::option::Option ::std::os::raw::c_int>, - pub log: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char, ...), - >, - pub soft_heap_limit64: - ::std::option::Option sqlite3_int64>, - pub sourceid: ::std::option::Option *const ::std::os::raw::c_char>, - pub stmt_status: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub strnicmp: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub unlock_notify: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub wal_autocheckpoint: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub wal_checkpoint: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub wal_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_api_routines() { - assert_eq!( - ::std::mem::size_of::(), - 1408usize, - concat!("Size of: ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_context as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_context) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_count as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_double as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_count as *const _ - as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_index as *const _ - as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_index) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_name as *const _ - as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_text16 as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_handler as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_handler) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_timeout as *const _ as usize - }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_timeout) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(close) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed as *const _ as usize - }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_blob as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes as *const _ as usize - }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize - }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_count as *const _ as usize - }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name as *const _ - as usize - }, - 184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name16 as *const _ - as usize - }, - 192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype as *const _ as usize - }, - 200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize - }, - 208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_double as *const _ as usize - }, - 216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, - 224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_int64 as *const _ as usize - }, - 232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name as *const _ as usize - }, - 240usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name16 as *const _ as usize - }, - 248usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name as *const _ as usize - }, - 256usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name16 as *const _ - as usize - }, - 264usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name as *const _ as usize - }, - 272usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name16 as *const _ - as usize - }, - 280usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text as *const _ as usize - }, - 288usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text16 as *const _ as usize - }, - 296usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_type as *const _ as usize - }, - 304usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_type) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_value as *const _ as usize - }, - 312usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).commit_hook as *const _ as usize - }, - 320usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(commit_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, - 328usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, - 336usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation as *const _ as usize - }, - 344usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation16 as *const _ as usize - }, - 352usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function as *const _ as usize - }, - 360usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function16 as *const _ as usize - }, - 368usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module as *const _ as usize - }, - 376usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, - 384usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(data_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, - 392usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).declare_vtab as *const _ as usize - }, - 400usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(declare_vtab) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).enable_shared_cache as *const _ - as usize - }, - 408usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(enable_shared_cache) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, - 416usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, - 424usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, - 432usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, - 440usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(exec) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, - 448usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(expired) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, - 456usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(finalize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, - 464usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, - 472usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_autocommit as *const _ as usize - }, - 480usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_autocommit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_auxdata as *const _ as usize - }, - 488usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, - 496usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).global_recover as *const _ as usize - }, - 504usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(global_recover) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, - 512usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(interruptx) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize - }, - 520usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(last_insert_rowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, - 528usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).libversion_number as *const _ as usize - }, - 536usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion_number) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, - 544usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(malloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, - 552usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, - 560usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, - 568usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, - 576usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, - 584usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, - 592usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(profile) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).progress_handler as *const _ as usize - }, - 600usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(progress_handler) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, - 608usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(realloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, - 616usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(reset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_blob as *const _ as usize - }, - 624usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_double as *const _ as usize - }, - 632usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_double) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error as *const _ as usize - }, - 640usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error16 as *const _ as usize - }, - 648usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, - 656usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_int64 as *const _ as usize - }, - 664usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_null as *const _ as usize - }, - 672usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text as *const _ as usize - }, - 680usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16 as *const _ as usize - }, - 688usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16be as *const _ as usize - }, - 696usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16le as *const _ as usize - }, - 704usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16le) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_value as *const _ as usize - }, - 712usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rollback_hook as *const _ as usize - }, - 720usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(rollback_hook) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_authorizer as *const _ as usize - }, - 728usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_authorizer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_auxdata as *const _ as usize - }, - 736usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).snprintf as *const _ as usize }, - 744usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(snprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, - 752usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(step) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).table_column_metadata as *const _ - as usize - }, - 760usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(table_column_metadata) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize - }, - 768usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(thread_cleanup) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).total_changes as *const _ as usize - }, - 776usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(total_changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, - 784usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(trace) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize - }, - 792usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(transfer_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).update_hook as *const _ as usize - }, - 800usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(update_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, - 808usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(user_data) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, - 816usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes as *const _ as usize - }, - 824usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize - }, - 832usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_double as *const _ as usize - }, - 840usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, - 848usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_int64 as *const _ as usize - }, - 856usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize - }, - 864usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_numeric_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, - 872usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16 as *const _ as usize - }, - 880usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16be as *const _ as usize - }, - 888usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16le as *const _ as usize - }, - 896usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16le) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, - 904usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, - 912usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vmprintf) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).overload_function as *const _ as usize - }, - 920usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(overload_function) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, - 928usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize - }, - 936usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).clear_bindings as *const _ as usize - }, - 944usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(clear_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize - }, - 952usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize - }, - 960usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_zeroblob) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, - 968usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_bytes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, - 976usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_close) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, - 984usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, - 992usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_read) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, - 1000usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_write) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation_v2 as *const _ - as usize - }, - 1008usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).file_control as *const _ as usize - }, - 1016usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(file_control) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_highwater as *const _ as usize - }, - 1024usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_highwater) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_used as *const _ as usize - }, - 1032usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_used) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize - }, - 1040usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_alloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_enter as *const _ as usize - }, - 1048usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_enter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, - 1056usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_free) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_leave as *const _ as usize - }, - 1064usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_leave) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, - 1072usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_try) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, - 1080usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).release_memory as *const _ as usize - }, - 1088usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(release_memory) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize - }, - 1096usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_nomem) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_toobig as *const _ - as usize - }, - 1104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_toobig) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, - 1112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sleep) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize - }, - 1120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(soft_heap_limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, - 1128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_find) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_register as *const _ as usize - }, - 1136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_register) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize - }, - 1144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_unregister) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize - }, - 1152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(xthreadsafe) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize - }, - 1160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_zeroblob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_code as *const _ as usize - }, - 1168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_code) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).test_control as *const _ as usize - }, - 1176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(test_control) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, - 1184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(randomness) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).context_db_handle as *const _ as usize - }, - 1192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(context_db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).extended_result_codes as *const _ - as usize - }, - 1200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(extended_result_codes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, - 1208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, - 1216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(next_stmt) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, - 1224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sql) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, - 1232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(status) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_finish as *const _ as usize - }, - 1240usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_finish) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_init as *const _ as usize - }, - 1248usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_init) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_pagecount as *const _ as usize - }, - 1256usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_pagecount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_remaining as *const _ as usize - }, - 1264usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_remaining) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_step as *const _ as usize - }, - 1272usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_step) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).compileoption_get as *const _ as usize - }, - 1280usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(compileoption_get) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).compileoption_used as *const _ as usize - }, - 1288usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(compileoption_used) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function_v2 as *const _ as usize - }, - 1296usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function_v2) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_config as *const _ as usize }, - 1304usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_config) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_mutex as *const _ as usize }, - 1312usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_mutex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_status as *const _ as usize }, - 1320usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_status) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).extended_errcode as *const _ as usize - }, - 1328usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(extended_errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).log as *const _ as usize }, - 1336usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(log) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).soft_heap_limit64 as *const _ as usize - }, - 1344usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(soft_heap_limit64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sourceid as *const _ as usize }, - 1352usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sourceid) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stmt_status as *const _ as usize - }, - 1360usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_status) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).strnicmp as *const _ as usize }, - 1368usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(strnicmp) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).unlock_notify as *const _ as usize - }, - 1376usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(unlock_notify) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_autocheckpoint as *const _ as usize - }, - 1384usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_autocheckpoint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_checkpoint as *const _ as usize - }, - 1392usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_checkpoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).wal_hook as *const _ as usize }, - 1400usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_hook) - ) - ); -} -pub type __builtin_va_list = [__va_list_tag; 1usize]; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct __va_list_tag { - pub gp_offset: ::std::os::raw::c_uint, - pub fp_offset: ::std::os::raw::c_uint, - pub overflow_arg_area: *mut ::std::os::raw::c_void, - pub reg_save_area: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout___va_list_tag() { - assert_eq!( - ::std::mem::size_of::<__va_list_tag>(), - 24usize, - concat!("Size of: ", stringify!(__va_list_tag)) - ); - assert_eq!( - ::std::mem::align_of::<__va_list_tag>(), - 8usize, - concat!("Alignment of ", stringify!(__va_list_tag)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(gp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(fp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(overflow_arg_area) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(reg_save_area) - ) - ); -} - -// bindings were built with (non-embedded) loadable_extension: -// we define our own sqlite_api static variable and export it -// to C -#[no_mangle] -pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_routines; - -// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) - -pub unsafe fn sqlite3_aggregate_context( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_context.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_context", - " function" - )))(arg1, nBytes) -} - -pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_blob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_blob", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_double( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_double", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_null( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_null", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_parameter_index( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_index.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_index", - " function" - )))(arg1, zName) -} - -pub unsafe fn sqlite3_bind_parameter_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_text( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_text16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_bind_value( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_value", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_handler( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_handler", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_timeout( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_timeout.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_timeout", - " function" - )))(arg1, ms) -} - -pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_collation_needed( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_collation_needed16( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_column_blob( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_blob", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_column_database_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_database_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_decltype( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype", - " function" - )))(arg1, i) -} - -pub unsafe fn sqlite3_column_decltype16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_double", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int64( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int64", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_text( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_text16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_type( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_type", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_value( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_value", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_commit_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).commit_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "commit_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete16", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_create_collation( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_collation16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_function( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_function16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function16", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_module( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).data_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "data_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_declare_vtab( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).declare_vtab.expect(stringify!( - "sqlite3_api contains null pointer for ", - "declare_vtab", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).enable_shared_cache.expect(stringify!( - "sqlite3_api contains null pointer for ", - "enable_shared_cache", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errcode", - " function" - )))(db) -} - -pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_exec( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).exec.expect(stringify!( - "sqlite3_api contains null pointer for ", - "exec", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).expired.expect(stringify!( - "sqlite3_api contains null pointer for ", - "expired", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).finalize.expect(stringify!( - "sqlite3_api contains null pointer for ", - "finalize", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free_table", - " function" - )))(result) -} - -pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_autocommit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_autocommit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_get_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_auxdata", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_get_table( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_table", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).global_recover.expect(stringify!( - "sqlite3_api contains null pointer for ", - "global_recover", - " function" - )))() -} - -pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).interruptx.expect(stringify!( - "sqlite3_api contains null pointer for ", - "interruptx", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).last_insert_rowid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "last_insert_rowid", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion", - " function" - )))() -} - -pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion_number.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion_number", - " function" - )))() -} - -pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).malloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "malloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mprintf( - arg1: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mprintf", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_open( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_open16( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_prepare( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_profile( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).profile.expect(stringify!( - "sqlite3_api contains null pointer for ", - "profile", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_progress_handler( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).progress_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "progress_handler", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_realloc( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).realloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "realloc", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).reset.expect(stringify!( - "sqlite3_api contains null pointer for ", - "reset", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_result_blob( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_blob", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_double", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_error16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_null", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_text( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16be( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16be", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16le( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16le", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_value", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_rollback_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).rollback_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "rollback_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_authorizer( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_authorizer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_authorizer", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_auxdata", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_snprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).snprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "snprintf", - " function" - )))(arg1, arg2, arg3, vararg1) -} - -pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).step.expect(stringify!( - "sqlite3_api contains null pointer for ", - "step", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_table_column_metadata( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).table_column_metadata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "table_column_metadata", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) -} - -pub unsafe fn sqlite3_thread_cleanup() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).thread_cleanup.expect(stringify!( - "sqlite3_api contains null pointer for ", - "thread_cleanup", - " function" - )))() -} - -pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).total_changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "total_changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_trace( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).trace.expect(stringify!( - "sqlite3_api contains null pointer for ", - "trace", - " function" - )))(arg1, xTrace, arg2) -} - -pub unsafe fn sqlite3_transfer_bindings( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).transfer_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "transfer_bindings", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_update_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).update_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "update_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).user_data.expect(stringify!( - "sqlite3_api contains null pointer for ", - "user_data", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_blob", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_double", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_numeric_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_numeric_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16be", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16le", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vmprintf( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vmprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vmprintf", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_overload_function( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).overload_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "overload_function", - " function" - )))(arg1, zFuncName, nArg) -} - -pub unsafe fn sqlite3_prepare_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).clear_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "clear_bindings", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_module_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module_v2", - " function" - )))(arg1, arg2, arg3, arg4, xDestroy) -} - -pub unsafe fn sqlite3_bind_zeroblob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_zeroblob", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_open( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_open", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) -} - -pub unsafe fn sqlite3_blob_read( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_read.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_read", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_blob_write( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_write.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_write", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_create_collation_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_file_control( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).file_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "file_control", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_highwater.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_highwater", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_used.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_used", - " function" - )))() -} - -pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_alloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_alloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_enter.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_enter", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_leave.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_leave", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_try.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_try", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_open_v2( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open_v2", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).release_memory.expect(stringify!( - "sqlite3_api contains null pointer for ", - "release_memory", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_nomem.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_nomem", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_toobig.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_toobig", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sleep.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sleep", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).soft_heap_limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "soft_heap_limit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_find.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_find", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_register( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_register.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_register", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_unregister.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_unregister", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).xthreadsafe.expect(stringify!( - "sqlite3_api contains null pointer for ", - "xthreadsafe", - " function" - )))() -} - -pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_zeroblob", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_code.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_code", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_test_control( - arg1: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).test_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "test_control", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).randomness.expect(stringify!( - "sqlite3_api contains null pointer for ", - "randomness", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).context_db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "context_db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_extended_result_codes( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).extended_result_codes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "extended_result_codes", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_limit( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "limit", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).next_stmt.expect(stringify!( - "sqlite3_api contains null pointer for ", - "next_stmt", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sql.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sql", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_status( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "status", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_finish.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_finish", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_init( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut sqlite3, - arg4: *const ::std::os::raw::c_char, -) -> *mut sqlite3_backup { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_init.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_init", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_pagecount.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_pagecount", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_remaining.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_remaining", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_step( - arg1: *mut sqlite3_backup, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_step.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_step", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_compileoption_get( - arg1: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).compileoption_get.expect(stringify!( - "sqlite3_api contains null pointer for ", - "compileoption_get", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_compileoption_used( - arg1: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).compileoption_used.expect(stringify!( - "sqlite3_api contains null pointer for ", - "compileoption_used", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_function_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal, xDestroy) -} - -pub unsafe fn sqlite3_db_config( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, - vararg2: &mut i32, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_config.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_config", - " function" - )))(arg1, arg2, vararg1, vararg2) -} - -pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_mutex.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_mutex", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_db_status( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_status", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).extended_errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "extended_errcode", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_log( - arg1: ::std::os::raw::c_int, - arg2: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).log.expect(stringify!( - "sqlite3_api contains null pointer for ", - "log", - " function" - )))(arg1, arg2, vararg1) -} - -pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).soft_heap_limit64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "soft_heap_limit64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sourceid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sourceid", - " function" - )))() -} - -pub unsafe fn sqlite3_stmt_status( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_status", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_strnicmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).strnicmp.expect(stringify!( - "sqlite3_api contains null pointer for ", - "strnicmp", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_unlock_notify( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int), - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).unlock_notify.expect(stringify!( - "sqlite3_api contains null pointer for ", - "unlock_notify", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_wal_autocheckpoint( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_autocheckpoint", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_wal_checkpoint( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_checkpoint.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_checkpoint", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_wal_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub const SQLITE_DETERMINISTIC: i32 = 2048; diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7.rs deleted file mode 100644 index 93c3eccbe..000000000 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7.rs +++ /dev/null @@ -1,3509 +0,0 @@ -/* automatically generated by rust-bindgen */ - -pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 6usize] = b"3.7.7\0"; -pub const SQLITE_VERSION_NUMBER: i32 = 3007007; -pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = - b"2011-06-23 19:49:22 4374b7e83ea0a3fbc3691f9c0c936272862f32f2\0"; -pub const SQLITE_OK: i32 = 0; -pub const SQLITE_ERROR: i32 = 1; -pub const SQLITE_INTERNAL: i32 = 2; -pub const SQLITE_PERM: i32 = 3; -pub const SQLITE_ABORT: i32 = 4; -pub const SQLITE_BUSY: i32 = 5; -pub const SQLITE_LOCKED: i32 = 6; -pub const SQLITE_NOMEM: i32 = 7; -pub const SQLITE_READONLY: i32 = 8; -pub const SQLITE_INTERRUPT: i32 = 9; -pub const SQLITE_IOERR: i32 = 10; -pub const SQLITE_CORRUPT: i32 = 11; -pub const SQLITE_NOTFOUND: i32 = 12; -pub const SQLITE_FULL: i32 = 13; -pub const SQLITE_CANTOPEN: i32 = 14; -pub const SQLITE_PROTOCOL: i32 = 15; -pub const SQLITE_EMPTY: i32 = 16; -pub const SQLITE_SCHEMA: i32 = 17; -pub const SQLITE_TOOBIG: i32 = 18; -pub const SQLITE_CONSTRAINT: i32 = 19; -pub const SQLITE_MISMATCH: i32 = 20; -pub const SQLITE_MISUSE: i32 = 21; -pub const SQLITE_NOLFS: i32 = 22; -pub const SQLITE_AUTH: i32 = 23; -pub const SQLITE_FORMAT: i32 = 24; -pub const SQLITE_RANGE: i32 = 25; -pub const SQLITE_NOTADB: i32 = 26; -pub const SQLITE_ROW: i32 = 100; -pub const SQLITE_DONE: i32 = 101; -pub const SQLITE_IOERR_READ: i32 = 266; -pub const SQLITE_IOERR_SHORT_READ: i32 = 522; -pub const SQLITE_IOERR_WRITE: i32 = 778; -pub const SQLITE_IOERR_FSYNC: i32 = 1034; -pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; -pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; -pub const SQLITE_IOERR_FSTAT: i32 = 1802; -pub const SQLITE_IOERR_UNLOCK: i32 = 2058; -pub const SQLITE_IOERR_RDLOCK: i32 = 2314; -pub const SQLITE_IOERR_DELETE: i32 = 2570; -pub const SQLITE_IOERR_BLOCKED: i32 = 2826; -pub const SQLITE_IOERR_NOMEM: i32 = 3082; -pub const SQLITE_IOERR_ACCESS: i32 = 3338; -pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; -pub const SQLITE_IOERR_LOCK: i32 = 3850; -pub const SQLITE_IOERR_CLOSE: i32 = 4106; -pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; -pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; -pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; -pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; -pub const SQLITE_IOERR_SHMMAP: i32 = 5386; -pub const SQLITE_IOERR_SEEK: i32 = 5642; -pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; -pub const SQLITE_BUSY_RECOVERY: i32 = 261; -pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; -pub const SQLITE_CORRUPT_VTAB: i32 = 267; -pub const SQLITE_READONLY_RECOVERY: i32 = 264; -pub const SQLITE_READONLY_CANTLOCK: i32 = 520; -pub const SQLITE_OPEN_READONLY: i32 = 1; -pub const SQLITE_OPEN_READWRITE: i32 = 2; -pub const SQLITE_OPEN_CREATE: i32 = 4; -pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; -pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; -pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; -pub const SQLITE_OPEN_URI: i32 = 64; -pub const SQLITE_OPEN_MAIN_DB: i32 = 256; -pub const SQLITE_OPEN_TEMP_DB: i32 = 512; -pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; -pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; -pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; -pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; -pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; -pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; -pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; -pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; -pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; -pub const SQLITE_OPEN_WAL: i32 = 524288; -pub const SQLITE_IOCAP_ATOMIC: i32 = 1; -pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; -pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; -pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; -pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; -pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; -pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; -pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; -pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; -pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; -pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; -pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; -pub const SQLITE_LOCK_NONE: i32 = 0; -pub const SQLITE_LOCK_SHARED: i32 = 1; -pub const SQLITE_LOCK_RESERVED: i32 = 2; -pub const SQLITE_LOCK_PENDING: i32 = 3; -pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; -pub const SQLITE_SYNC_NORMAL: i32 = 2; -pub const SQLITE_SYNC_FULL: i32 = 3; -pub const SQLITE_SYNC_DATAONLY: i32 = 16; -pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; -pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_LAST_ERRNO: i32 = 4; -pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; -pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; -pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; -pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; -pub const SQLITE_ACCESS_EXISTS: i32 = 0; -pub const SQLITE_ACCESS_READWRITE: i32 = 1; -pub const SQLITE_ACCESS_READ: i32 = 2; -pub const SQLITE_SHM_UNLOCK: i32 = 1; -pub const SQLITE_SHM_LOCK: i32 = 2; -pub const SQLITE_SHM_SHARED: i32 = 4; -pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; -pub const SQLITE_SHM_NLOCK: i32 = 8; -pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; -pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; -pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; -pub const SQLITE_CONFIG_MALLOC: i32 = 4; -pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; -pub const SQLITE_CONFIG_SCRATCH: i32 = 6; -pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; -pub const SQLITE_CONFIG_HEAP: i32 = 8; -pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; -pub const SQLITE_CONFIG_MUTEX: i32 = 10; -pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; -pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; -pub const SQLITE_CONFIG_PCACHE: i32 = 14; -pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; -pub const SQLITE_CONFIG_LOG: i32 = 16; -pub const SQLITE_CONFIG_URI: i32 = 17; -pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; -pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; -pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; -pub const SQLITE_DENY: i32 = 1; -pub const SQLITE_IGNORE: i32 = 2; -pub const SQLITE_CREATE_INDEX: i32 = 1; -pub const SQLITE_CREATE_TABLE: i32 = 2; -pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; -pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; -pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; -pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; -pub const SQLITE_CREATE_TRIGGER: i32 = 7; -pub const SQLITE_CREATE_VIEW: i32 = 8; -pub const SQLITE_DELETE: i32 = 9; -pub const SQLITE_DROP_INDEX: i32 = 10; -pub const SQLITE_DROP_TABLE: i32 = 11; -pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; -pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; -pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; -pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; -pub const SQLITE_DROP_TRIGGER: i32 = 16; -pub const SQLITE_DROP_VIEW: i32 = 17; -pub const SQLITE_INSERT: i32 = 18; -pub const SQLITE_PRAGMA: i32 = 19; -pub const SQLITE_READ: i32 = 20; -pub const SQLITE_SELECT: i32 = 21; -pub const SQLITE_TRANSACTION: i32 = 22; -pub const SQLITE_UPDATE: i32 = 23; -pub const SQLITE_ATTACH: i32 = 24; -pub const SQLITE_DETACH: i32 = 25; -pub const SQLITE_ALTER_TABLE: i32 = 26; -pub const SQLITE_REINDEX: i32 = 27; -pub const SQLITE_ANALYZE: i32 = 28; -pub const SQLITE_CREATE_VTABLE: i32 = 29; -pub const SQLITE_DROP_VTABLE: i32 = 30; -pub const SQLITE_FUNCTION: i32 = 31; -pub const SQLITE_SAVEPOINT: i32 = 32; -pub const SQLITE_COPY: i32 = 0; -pub const SQLITE_LIMIT_LENGTH: i32 = 0; -pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; -pub const SQLITE_LIMIT_COLUMN: i32 = 2; -pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; -pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; -pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; -pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; -pub const SQLITE_LIMIT_ATTACHED: i32 = 7; -pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; -pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; -pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; -pub const SQLITE_INTEGER: i32 = 1; -pub const SQLITE_FLOAT: i32 = 2; -pub const SQLITE_BLOB: i32 = 4; -pub const SQLITE_NULL: i32 = 5; -pub const SQLITE_TEXT: i32 = 3; -pub const SQLITE3_TEXT: i32 = 3; -pub const SQLITE_UTF8: i32 = 1; -pub const SQLITE_UTF16LE: i32 = 2; -pub const SQLITE_UTF16BE: i32 = 3; -pub const SQLITE_UTF16: i32 = 4; -pub const SQLITE_ANY: i32 = 5; -pub const SQLITE_UTF16_ALIGNED: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; -pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; -pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; -pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; -pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; -pub const SQLITE_MUTEX_FAST: i32 = 0; -pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; -pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; -pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; -pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; -pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; -pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; -pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; -pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; -pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; -pub const SQLITE_TESTCTRL_FIRST: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; -pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; -pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; -pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; -pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; -pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; -pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; -pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; -pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; -pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; -pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; -pub const SQLITE_TESTCTRL_PGHDRSZ: i32 = 17; -pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 18; -pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 19; -pub const SQLITE_TESTCTRL_LAST: i32 = 19; -pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; -pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; -pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; -pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; -pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; -pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; -pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; -pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; -pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; -pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; -pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; -pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; -pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; -pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; -pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; -pub const SQLITE_DBSTATUS_MAX: i32 = 6; -pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; -pub const SQLITE_STMTSTATUS_SORT: i32 = 2; -pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; -pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; -pub const SQLITE_CHECKPOINT_FULL: i32 = 1; -pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; -pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; -pub const SQLITE_ROLLBACK: i32 = 1; -pub const SQLITE_FAIL: i32 = 3; -pub const SQLITE_REPLACE: i32 = 5; -pub type va_list = __builtin_va_list; -pub type __gnuc_va_list = __builtin_va_list; -extern "C" { - #[link_name = "\u{1}sqlite3_version"] - pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; -} -extern "C" { - pub fn sqlite3_libversion() -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_sourceid() -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_libversion_number() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_compileoption_used( - zOptName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_compileoption_get(N: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_threadsafe() -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3 { - _unused: [u8; 0], -} -pub type sqlite_int64 = ::std::os::raw::c_longlong; -pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; -pub type sqlite3_int64 = sqlite_int64; -pub type sqlite3_uint64 = sqlite_uint64; -extern "C" { - pub fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -pub type sqlite3_callback = ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, ->; -extern "C" { - pub fn sqlite3_exec( - arg1: *mut sqlite3, - sql: *const ::std::os::raw::c_char, - callback: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg2: *mut ::std::os::raw::c_void, - errmsg: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_file { - pub pMethods: *const sqlite3_io_methods, -} -#[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_file)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_file)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_file), - "::", - stringify!(pMethods) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_io_methods { - pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xRead: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *mut ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xWrite: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *const ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pSize: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xUnlock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCheckReservedLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileControl: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - op: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xSectorSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xDeviceCharacteristics: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xShmMap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iPg: ::std::os::raw::c_int, - pgsz: ::std::os::raw::c_int, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xShmLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - offset: ::std::os::raw::c_int, - n: ::std::os::raw::c_int, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xShmBarrier: ::std::option::Option, - pub xShmUnmap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - deleteFlag: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_io_methods() { - assert_eq!( - ::std::mem::size_of::(), - 136usize, - concat!("Size of: ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xRead) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xWrite) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnlock) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xCheckReservedLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileControl) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSectorSize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ - as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xDeviceCharacteristics) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmMap) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmBarrier) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmUnmap) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex { - _unused: [u8; 0], -} -pub type sqlite3_syscall_ptr = ::std::option::Option; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vfs { - pub iVersion: ::std::os::raw::c_int, - pub szOsFile: ::std::os::raw::c_int, - pub mxPathname: ::std::os::raw::c_int, - pub pNext: *mut sqlite3_vfs, - pub zName: *const ::std::os::raw::c_char, - pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - pOutFlags: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - syncDir: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xAccess: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - flags: ::std::os::raw::c_int, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFullPathname: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - nOut: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xDlOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zFilename: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void, - >, - pub xDlError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zErrMsg: *mut ::std::os::raw::c_char, - ), - >, - pub xDlSym: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ) -> ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ), - >, - >, - pub xDlClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), - >, - pub xRandomness: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSleep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - microseconds: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTime: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, - >, - pub xGetLastError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTimeInt64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xSetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: sqlite3_syscall_ptr, - ) -> ::std::os::raw::c_int, - >, - pub xGetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> sqlite3_syscall_ptr, - >, - pub xNextSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!( - ::std::mem::size_of::(), - 168usize, - concat!("Size of: ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(szOsFile) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(mxPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(zName) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pAppData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xAccess) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xFullPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlSym) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xRandomness) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSleep) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTime) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetLastError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTimeInt64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xNextSystemCall) - ) - ); -} -extern "C" { - pub fn sqlite3_initialize() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_shutdown() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_os_init() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_os_end() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_db_config( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xRoundup: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub pAppData: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!( - ::std::mem::size_of::(), - 64usize, - concat!("Size of: ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xMalloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xFree) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRealloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRoundup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(pAppData) - ) - ); -} -extern "C" { - pub fn sqlite3_extended_result_codes( - arg1: *mut sqlite3, - onoff: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_interrupt(arg1: *mut sqlite3); -} -extern "C" { - pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_busy_handler( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_busy_timeout( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_get_table( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - pazResult: *mut *mut *mut ::std::os::raw::c_char, - pnRow: *mut ::std::os::raw::c_int, - pnColumn: *mut ::std::os::raw::c_int, - pzErrmsg: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char); -} -extern "C" { - pub fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char, ...) - -> *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_vmprintf( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_snprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_vsnprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_realloc( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_free(arg1: *mut ::std::os::raw::c_void); -} -extern "C" { - pub fn sqlite3_memory_used() -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_randomness(N: ::std::os::raw::c_int, P: *mut ::std::os::raw::c_void); -} -extern "C" { - pub fn sqlite3_set_authorizer( - arg1: *mut sqlite3, - xAuth: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pUserData: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_trace( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_profile( - arg1: *mut sqlite3, - xProfile: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_uint64, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_progress_handler( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, - ); -} -extern "C" { - pub fn sqlite3_open( - filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_open16( - filename: *const ::std::os::raw::c_void, - ppDb: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_open_v2( - filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3, - flags: ::std::os::raw::c_int, - zVfs: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_uri_parameter( - zFilename: *const ::std::os::raw::c_char, - zParam: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_extended_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt { - _unused: [u8; 0], -} -extern "C" { - pub fn sqlite3_limit( - arg1: *mut sqlite3, - id: ::std::os::raw::c_int, - newVal: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_prepare( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_prepare_v2( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_prepare16( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_prepare16_v2( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_stmt_readonly(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Mem { - _unused: [u8; 0], -} -pub type sqlite3_value = Mem; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_context { - _unused: [u8; 0], -} -extern "C" { - pub fn sqlite3_bind_blob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_double( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_int( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_int64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_int64, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_null( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_text( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_text16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_value( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_zeroblob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - n: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_parameter_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_bind_parameter_index( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_name( - arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_column_name16( - arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_database_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_column_database_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_table_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_column_table_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_origin_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_column_origin_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_decltype( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_column_decltype16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_blob( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_bytes( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_bytes16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64; -} -extern "C" { - pub fn sqlite3_column_int( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_int64( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_column_text( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_uchar; -} -extern "C" { - pub fn sqlite3_column_text16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_type( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_value( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *mut sqlite3_value; -} -extern "C" { - pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function( - db: *mut sqlite3, - zFunctionName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function16( - db: *mut sqlite3, - zFunctionName: *const ::std::os::raw::c_void, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function_v2( - db: *mut sqlite3, - zFunctionName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_transfer_bindings( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_global_recover() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_thread_cleanup(); -} -extern "C" { - pub fn sqlite3_memory_alarm( - arg1: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: sqlite3_int64, - arg3: ::std::os::raw::c_int, - ), - >, - arg2: *mut ::std::os::raw::c_void, - arg3: sqlite3_int64, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64; -} -extern "C" { - pub fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar; -} -extern "C" { - pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_aggregate_context( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3; -} -extern "C" { - pub fn sqlite3_get_auxdata( - arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_set_auxdata( - arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option, - ); -} -pub type sqlite3_destructor_type = - ::std::option::Option; -extern "C" { - pub fn sqlite3_result_blob( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64); -} -extern "C" { - pub fn sqlite3_result_error( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ); -} -extern "C" { - pub fn sqlite3_result_error16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - ); -} -extern "C" { - pub fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context); -} -extern "C" { - pub fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context); -} -extern "C" { - pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite3_int64); -} -extern "C" { - pub fn sqlite3_result_null(arg1: *mut sqlite3_context); -} -extern "C" { - pub fn sqlite3_result_text( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_text16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_text16le( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_text16be( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value); -} -extern "C" { - pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, n: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_create_collation( - arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - xCompare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation_v2( - arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - xCompare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation16( - arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_void, - eTextRep: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - xCompare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed16( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; -} -extern "C" { - #[link_name = "\u{1}sqlite3_temp_directory"] - pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3; -} -extern "C" { - pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) -> *mut sqlite3_stmt; -} -extern "C" { - pub fn sqlite3_commit_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_rollback_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_update_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_soft_heap_limit64(N: sqlite3_int64) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_soft_heap_limit(N: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_table_column_metadata( - db: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - zTableName: *const ::std::os::raw::c_char, - zColumnName: *const ::std::os::raw::c_char, - pzDataType: *mut *const ::std::os::raw::c_char, - pzCollSeq: *mut *const ::std::os::raw::c_char, - pNotNull: *mut ::std::os::raw::c_int, - pPrimaryKey: *mut ::std::os::raw::c_int, - pAutoinc: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_load_extension( - db: *mut sqlite3, - zFile: *const ::std::os::raw::c_char, - zProc: *const ::std::os::raw::c_char, - pzErrMsg: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_enable_load_extension( - db: *mut sqlite3, - onoff: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_auto_extension( - xEntryPoint: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_reset_auto_extension(); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xConnect: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xBestIndex: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: *mut sqlite3_index_info, - ) -> ::std::os::raw::c_int, - >, - pub xDisconnect: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xDestroy: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - ppCursor: *mut *mut sqlite3_vtab_cursor, - ) -> ::std::os::raw::c_int, - >, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xFilter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - idxNum: ::std::os::raw::c_int, - idxStr: *const ::std::os::raw::c_char, - argc: ::std::os::raw::c_int, - argv: *mut *mut sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub xNext: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xEof: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - arg2: *mut sqlite3_context, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - pRowid: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xUpdate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - arg4: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xBegin: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xCommit: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xRollback: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xFindFunction: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - nArg: ::std::os::raw::c_int, - zName: *const ::std::os::raw::c_char, - pxFunc: *mut ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - ppArg: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xRename: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - zNew: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSavepoint: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRelease: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRollbackTo: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!( - ::std::mem::size_of::(), - 184usize, - concat!("Size of: ", stringify!(sqlite3_module)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_module)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xConnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBestIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDisconnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFilter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xEof) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xColumn) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xUpdate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBegin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCommit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollback) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFindFunction) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRename) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSavepoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRelease) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollbackTo) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info { - pub nConstraint: ::std::os::raw::c_int, - pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, - pub nOrderBy: ::std::os::raw::c_int, - pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, - pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, - pub idxNum: ::std::os::raw::c_int, - pub idxStr: *mut ::std::os::raw::c_char, - pub needToFreeIdxStr: ::std::os::raw::c_int, - pub orderByConsumed: ::std::os::raw::c_int, - pub estimatedCost: f64, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint { - pub iColumn: ::std::os::raw::c_int, - pub op: ::std::os::raw::c_uchar, - pub usable: ::std::os::raw::c_uchar, - pub iTermOffset: ::std::os::raw::c_int, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).op as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(op) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).usable - as *const _ as usize - }, - 5usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(usable) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iTermOffset - as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iTermOffset) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_orderby { - pub iColumn: ::std::os::raw::c_int, - pub desc: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).desc as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(desc) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint_usage { - pub argvIndex: ::std::os::raw::c_int, - pub omit: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).argvIndex - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(argvIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).omit - as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(omit) - ) - ); -} -#[test] -fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nOrderBy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aOrderBy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraintUsage) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxNum) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(needToFreeIdxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(orderByConsumed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedCost as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedCost) - ) - ); -} -extern "C" { - pub fn sqlite3_create_module( - db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - p: *const sqlite3_module, - pClientData: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_module_v2( - db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - p: *const sqlite3_module, - pClientData: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(pModule) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(nRef) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(zErrMsg) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab_cursor { - pub pVtab: *mut sqlite3_vtab, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab_cursor), - "::", - stringify!(pVtab) - ) - ); -} -extern "C" { - pub fn sqlite3_declare_vtab( - arg1: *mut sqlite3, - zSQL: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_overload_function( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob { - _unused: [u8; 0], -} -extern "C" { - pub fn sqlite3_blob_open( - arg1: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - zTable: *const ::std::os::raw::c_char, - zColumn: *const ::std::os::raw::c_char, - iRow: sqlite3_int64, - flags: ::std::os::raw::c_int, - ppBlob: *mut *mut sqlite3_blob, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_blob_reopen( - arg1: *mut sqlite3_blob, - arg2: sqlite3_int64, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_blob_read( - arg1: *mut sqlite3_blob, - Z: *mut ::std::os::raw::c_void, - N: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_blob_write( - arg1: *mut sqlite3_blob, - z: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs; -} -extern "C" { - pub fn sqlite3_vfs_register( - arg1: *mut sqlite3_vfs, - makeDflt: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex; -} -extern "C" { - pub fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex); -} -extern "C" { - pub fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex); -} -extern "C" { - pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexNotheld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexInit as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnd) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexAlloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexFree as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexFree) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexTry) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexLeave) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexHeld) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexNotheld) - ) - ); -} -extern "C" { - pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex; -} -extern "C" { - pub fn sqlite3_file_control( - arg1: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - op: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_status( - op: ::std::os::raw::c_int, - pCurrent: *mut ::std::os::raw::c_int, - pHighwater: *mut ::std::os::raw::c_int, - resetFlag: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_db_status( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - pCur: *mut ::std::os::raw::c_int, - pHiwtr: *mut ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_stmt_status( - arg1: *mut sqlite3_stmt, - op: ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods { - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!( - ::std::mem::size_of::(), - 88usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xDestroy) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_backup { - _unused: [u8; 0], -} -extern "C" { - pub fn sqlite3_backup_init( - pDest: *mut sqlite3, - zDestName: *const ::std::os::raw::c_char, - pSource: *mut sqlite3, - zSourceName: *const ::std::os::raw::c_char, - ) -> *mut sqlite3_backup; -} -extern "C" { - pub fn sqlite3_backup_step( - p: *mut sqlite3_backup, - nPage: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_backup_finish(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_backup_remaining(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_backup_pagecount(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_unlock_notify( - pBlocked: *mut sqlite3, - xNotify: ::std::option::Option< - unsafe extern "C" fn( - apArg: *mut *mut ::std::os::raw::c_void, - nArg: ::std::os::raw::c_int, - ), - >, - pNotifyArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_strnicmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_log( - iErrCode: ::std::os::raw::c_int, - zFormat: *const ::std::os::raw::c_char, - ... - ); -} -extern "C" { - pub fn sqlite3_wal_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_wal_autocheckpoint( - db: *mut sqlite3, - N: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_wal_checkpoint( - db: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_wal_checkpoint_v2( - db: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - eMode: ::std::os::raw::c_int, - pnLog: *mut ::std::os::raw::c_int, - pnCkpt: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_vtab_config( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_rtree_geometry_callback( - db: *mut sqlite3, - zGeom: *const ::std::os::raw::c_char, - xGeom: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_rtree_geometry, - nCoord: ::std::os::raw::c_int, - aCoord: *mut f64, - pRes: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pContext: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_rtree_geometry { - pub pContext: *mut ::std::os::raw::c_void, - pub nParam: ::std::os::raw::c_int, - pub aParam: *mut f64, - pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_rtree_geometry() { - assert_eq!( - ::std::mem::size_of::(), - 40usize, - concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pContext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(nParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(aParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pUser) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(xDelUser) - ) - ); -} -pub type __builtin_va_list = [__va_list_tag; 1usize]; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct __va_list_tag { - pub gp_offset: ::std::os::raw::c_uint, - pub fp_offset: ::std::os::raw::c_uint, - pub overflow_arg_area: *mut ::std::os::raw::c_void, - pub reg_save_area: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout___va_list_tag() { - assert_eq!( - ::std::mem::size_of::<__va_list_tag>(), - 24usize, - concat!("Size of: ", stringify!(__va_list_tag)) - ); - assert_eq!( - ::std::mem::align_of::<__va_list_tag>(), - 8usize, - concat!("Alignment of ", stringify!(__va_list_tag)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(gp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(fp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(overflow_arg_area) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(reg_save_area) - ) - ); -} -pub const SQLITE_DETERMINISTIC: i32 = 2048; diff --git a/libsqlite3-sys/bindgen-bindings/generate-bindgen-bindings.sh b/libsqlite3-sys/bindgen-bindings/generate-bindgen-bindings.sh index a2d31b3fa..01ceb7bfa 100755 --- a/libsqlite3-sys/bindgen-bindings/generate-bindgen-bindings.sh +++ b/libsqlite3-sys/bindgen-bindings/generate-bindgen-bindings.sh @@ -69,10 +69,6 @@ function generate_bindgen_binding { cp "${bindgen_file}" "${output_path}" } -generate_bindgen_bindings 3.26.0 https://sqlite.org/2018/sqlite-amalgamation-3260000.zip sqlite-amalgamation-3260000/ generate_bindgen_bindings 3.20.0 https://sqlite.org/2017/sqlite-amalgamation-3200000.zip sqlite-amalgamation-3200000/ -generate_bindgen_bindings 3.13.0 https://sqlite.org/2016/sqlite-amalgamation-3130000.zip sqlite-amalgamation-3130000/ generate_bindgen_bindings 3.7.16 https://sqlite.org/2013/sqlite-amalgamation-3071600.zip sqlite-amalgamation-3071600/ -generate_bindgen_bindings 3.7.7 https://sqlite.org/sqlite-amalgamation-3070700.zip sqlite-amalgamation-3070700/ -generate_bindgen_bindings 3.6.23 https://sqlite.org/sqlite-amalgamation-3_6_23.zip ./ generate_bindgen_bindings 3.6.8 https://sqlite.org/sqlite-amalgamation-3_6_8.zip ./ diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index 1e1ad24e7..70844d128 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -404,10 +404,6 @@ mod bindings { static PREBUILT_BINDGEN_PATHS: &'static [&'static str] = &[ "bindgen-bindings/bindgen_3.6.8", - #[cfg(feature = "min_sqlite_version_3_6_23")] - "bindgen-bindings/bindgen_3.6.23", - #[cfg(feature = "min_sqlite_version_3_7_7")] - "bindgen-bindings/bindgen_3.7.7", #[cfg(feature = "min_sqlite_version_3_7_16")] "bindgen-bindings/bindgen_3.7.16", #[cfg(feature = "min_sqlite_version_3_20_0")] From e1fffce7636e30b44b4b28e383687d299bd00e5b Mon Sep 17 00:00:00 2001 From: gwenn Date: Tue, 11 Feb 2020 20:31:21 +0100 Subject: [PATCH 07/61] Remove unused `api_routines_stub` feature --- Cargo.toml | 2 - libsqlite3-sys/Cargo.toml | 1 - .../bindgen_3.20.0-ext-embed.rs | 10509 ---------------- .../bindgen-bindings/bindgen_3.20.0-ext.rs | 10507 --------------- .../bindgen-bindings/bindgen_3.20.0.rs | 5030 -------- .../generate-bindgen-bindings.sh | 1 - libsqlite3-sys/build.rs | 2 - 7 files changed, 26052 deletions(-) delete mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.20.0-ext-embed.rs delete mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.20.0-ext.rs delete mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.20.0.rs diff --git a/Cargo.toml b/Cargo.toml index b09202d18..a2c602a9b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -59,8 +59,6 @@ series = ["vtab"] # check for invalid query. extra_check = [] modern_sqlite = ["libsqlite3-sys/bundled_bindings"] -# sqlite3_api_routines typedef stub: 3.20.0 -api_routines_stub = ["libsqlite3-sys/min_sqlite_version_3_20_0"] [dependencies] time = "0.1.0" diff --git a/libsqlite3-sys/Cargo.toml b/libsqlite3-sys/Cargo.toml index c2dc3b52b..b3aae2b4b 100644 --- a/libsqlite3-sys/Cargo.toml +++ b/libsqlite3-sys/Cargo.toml @@ -21,7 +21,6 @@ loadable_extension_embedded = ["loadable_extension"] sqlcipher = [] min_sqlite_version_3_6_8 = ["pkg-config", "vcpkg"] min_sqlite_version_3_7_16 = ["pkg-config", "vcpkg"] -min_sqlite_version_3_20_0 = ["pkg-config", "vcpkg"] # Bundle only the bindings file. Note that this does nothing if # `buildtime_bindgen` is enabled. bundled_bindings = [] diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.20.0-ext-embed.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.20.0-ext-embed.rs deleted file mode 100644 index 43ed41594..000000000 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.20.0-ext-embed.rs +++ /dev/null @@ -1,10509 +0,0 @@ -/* automatically generated by rust-bindgen */ - -pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.20.0\0"; -pub const SQLITE_VERSION_NUMBER: i32 = 3020000; -pub const SQLITE_SOURCE_ID: &'static [u8; 85usize] = - b"2017-08-01 13:24:15 9501e22dfeebdcefa783575e47c60b514d7c2e0cad73b2a496c0bc4b680900a8\0"; -pub const SQLITE_OK: i32 = 0; -pub const SQLITE_ERROR: i32 = 1; -pub const SQLITE_INTERNAL: i32 = 2; -pub const SQLITE_PERM: i32 = 3; -pub const SQLITE_ABORT: i32 = 4; -pub const SQLITE_BUSY: i32 = 5; -pub const SQLITE_LOCKED: i32 = 6; -pub const SQLITE_NOMEM: i32 = 7; -pub const SQLITE_READONLY: i32 = 8; -pub const SQLITE_INTERRUPT: i32 = 9; -pub const SQLITE_IOERR: i32 = 10; -pub const SQLITE_CORRUPT: i32 = 11; -pub const SQLITE_NOTFOUND: i32 = 12; -pub const SQLITE_FULL: i32 = 13; -pub const SQLITE_CANTOPEN: i32 = 14; -pub const SQLITE_PROTOCOL: i32 = 15; -pub const SQLITE_EMPTY: i32 = 16; -pub const SQLITE_SCHEMA: i32 = 17; -pub const SQLITE_TOOBIG: i32 = 18; -pub const SQLITE_CONSTRAINT: i32 = 19; -pub const SQLITE_MISMATCH: i32 = 20; -pub const SQLITE_MISUSE: i32 = 21; -pub const SQLITE_NOLFS: i32 = 22; -pub const SQLITE_AUTH: i32 = 23; -pub const SQLITE_FORMAT: i32 = 24; -pub const SQLITE_RANGE: i32 = 25; -pub const SQLITE_NOTADB: i32 = 26; -pub const SQLITE_NOTICE: i32 = 27; -pub const SQLITE_WARNING: i32 = 28; -pub const SQLITE_ROW: i32 = 100; -pub const SQLITE_DONE: i32 = 101; -pub const SQLITE_IOERR_READ: i32 = 266; -pub const SQLITE_IOERR_SHORT_READ: i32 = 522; -pub const SQLITE_IOERR_WRITE: i32 = 778; -pub const SQLITE_IOERR_FSYNC: i32 = 1034; -pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; -pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; -pub const SQLITE_IOERR_FSTAT: i32 = 1802; -pub const SQLITE_IOERR_UNLOCK: i32 = 2058; -pub const SQLITE_IOERR_RDLOCK: i32 = 2314; -pub const SQLITE_IOERR_DELETE: i32 = 2570; -pub const SQLITE_IOERR_BLOCKED: i32 = 2826; -pub const SQLITE_IOERR_NOMEM: i32 = 3082; -pub const SQLITE_IOERR_ACCESS: i32 = 3338; -pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; -pub const SQLITE_IOERR_LOCK: i32 = 3850; -pub const SQLITE_IOERR_CLOSE: i32 = 4106; -pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; -pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; -pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; -pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; -pub const SQLITE_IOERR_SHMMAP: i32 = 5386; -pub const SQLITE_IOERR_SEEK: i32 = 5642; -pub const SQLITE_IOERR_DELETE_NOENT: i32 = 5898; -pub const SQLITE_IOERR_MMAP: i32 = 6154; -pub const SQLITE_IOERR_GETTEMPPATH: i32 = 6410; -pub const SQLITE_IOERR_CONVPATH: i32 = 6666; -pub const SQLITE_IOERR_VNODE: i32 = 6922; -pub const SQLITE_IOERR_AUTH: i32 = 7178; -pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; -pub const SQLITE_BUSY_RECOVERY: i32 = 261; -pub const SQLITE_BUSY_SNAPSHOT: i32 = 517; -pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; -pub const SQLITE_CANTOPEN_ISDIR: i32 = 526; -pub const SQLITE_CANTOPEN_FULLPATH: i32 = 782; -pub const SQLITE_CANTOPEN_CONVPATH: i32 = 1038; -pub const SQLITE_CORRUPT_VTAB: i32 = 267; -pub const SQLITE_READONLY_RECOVERY: i32 = 264; -pub const SQLITE_READONLY_CANTLOCK: i32 = 520; -pub const SQLITE_READONLY_ROLLBACK: i32 = 776; -pub const SQLITE_READONLY_DBMOVED: i32 = 1032; -pub const SQLITE_ABORT_ROLLBACK: i32 = 516; -pub const SQLITE_CONSTRAINT_CHECK: i32 = 275; -pub const SQLITE_CONSTRAINT_COMMITHOOK: i32 = 531; -pub const SQLITE_CONSTRAINT_FOREIGNKEY: i32 = 787; -pub const SQLITE_CONSTRAINT_FUNCTION: i32 = 1043; -pub const SQLITE_CONSTRAINT_NOTNULL: i32 = 1299; -pub const SQLITE_CONSTRAINT_PRIMARYKEY: i32 = 1555; -pub const SQLITE_CONSTRAINT_TRIGGER: i32 = 1811; -pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067; -pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323; -pub const SQLITE_CONSTRAINT_ROWID: i32 = 2579; -pub const SQLITE_NOTICE_RECOVER_WAL: i32 = 283; -pub const SQLITE_NOTICE_RECOVER_ROLLBACK: i32 = 539; -pub const SQLITE_WARNING_AUTOINDEX: i32 = 284; -pub const SQLITE_AUTH_USER: i32 = 279; -pub const SQLITE_OK_LOAD_PERMANENTLY: i32 = 256; -pub const SQLITE_OPEN_READONLY: i32 = 1; -pub const SQLITE_OPEN_READWRITE: i32 = 2; -pub const SQLITE_OPEN_CREATE: i32 = 4; -pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; -pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; -pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; -pub const SQLITE_OPEN_URI: i32 = 64; -pub const SQLITE_OPEN_MEMORY: i32 = 128; -pub const SQLITE_OPEN_MAIN_DB: i32 = 256; -pub const SQLITE_OPEN_TEMP_DB: i32 = 512; -pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; -pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; -pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; -pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; -pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; -pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; -pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; -pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; -pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; -pub const SQLITE_OPEN_WAL: i32 = 524288; -pub const SQLITE_IOCAP_ATOMIC: i32 = 1; -pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; -pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; -pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; -pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; -pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; -pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; -pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; -pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; -pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; -pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; -pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; -pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE: i32 = 4096; -pub const SQLITE_IOCAP_IMMUTABLE: i32 = 8192; -pub const SQLITE_LOCK_NONE: i32 = 0; -pub const SQLITE_LOCK_SHARED: i32 = 1; -pub const SQLITE_LOCK_RESERVED: i32 = 2; -pub const SQLITE_LOCK_PENDING: i32 = 3; -pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; -pub const SQLITE_SYNC_NORMAL: i32 = 2; -pub const SQLITE_SYNC_FULL: i32 = 3; -pub const SQLITE_SYNC_DATAONLY: i32 = 16; -pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; -pub const SQLITE_FCNTL_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_FCNTL_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_FCNTL_LAST_ERRNO: i32 = 4; -pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; -pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; -pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; -pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; -pub const SQLITE_FCNTL_WIN32_AV_RETRY: i32 = 9; -pub const SQLITE_FCNTL_PERSIST_WAL: i32 = 10; -pub const SQLITE_FCNTL_OVERWRITE: i32 = 11; -pub const SQLITE_FCNTL_VFSNAME: i32 = 12; -pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE: i32 = 13; -pub const SQLITE_FCNTL_PRAGMA: i32 = 14; -pub const SQLITE_FCNTL_BUSYHANDLER: i32 = 15; -pub const SQLITE_FCNTL_TEMPFILENAME: i32 = 16; -pub const SQLITE_FCNTL_MMAP_SIZE: i32 = 18; -pub const SQLITE_FCNTL_TRACE: i32 = 19; -pub const SQLITE_FCNTL_HAS_MOVED: i32 = 20; -pub const SQLITE_FCNTL_SYNC: i32 = 21; -pub const SQLITE_FCNTL_COMMIT_PHASETWO: i32 = 22; -pub const SQLITE_FCNTL_WIN32_SET_HANDLE: i32 = 23; -pub const SQLITE_FCNTL_WAL_BLOCK: i32 = 24; -pub const SQLITE_FCNTL_ZIPVFS: i32 = 25; -pub const SQLITE_FCNTL_RBU: i32 = 26; -pub const SQLITE_FCNTL_VFS_POINTER: i32 = 27; -pub const SQLITE_FCNTL_JOURNAL_POINTER: i32 = 28; -pub const SQLITE_FCNTL_WIN32_GET_HANDLE: i32 = 29; -pub const SQLITE_FCNTL_PDB: i32 = 30; -pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_LAST_ERRNO: i32 = 4; -pub const SQLITE_ACCESS_EXISTS: i32 = 0; -pub const SQLITE_ACCESS_READWRITE: i32 = 1; -pub const SQLITE_ACCESS_READ: i32 = 2; -pub const SQLITE_SHM_UNLOCK: i32 = 1; -pub const SQLITE_SHM_LOCK: i32 = 2; -pub const SQLITE_SHM_SHARED: i32 = 4; -pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; -pub const SQLITE_SHM_NLOCK: i32 = 8; -pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; -pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; -pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; -pub const SQLITE_CONFIG_MALLOC: i32 = 4; -pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; -pub const SQLITE_CONFIG_SCRATCH: i32 = 6; -pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; -pub const SQLITE_CONFIG_HEAP: i32 = 8; -pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; -pub const SQLITE_CONFIG_MUTEX: i32 = 10; -pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; -pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; -pub const SQLITE_CONFIG_PCACHE: i32 = 14; -pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; -pub const SQLITE_CONFIG_LOG: i32 = 16; -pub const SQLITE_CONFIG_URI: i32 = 17; -pub const SQLITE_CONFIG_PCACHE2: i32 = 18; -pub const SQLITE_CONFIG_GETPCACHE2: i32 = 19; -pub const SQLITE_CONFIG_COVERING_INDEX_SCAN: i32 = 20; -pub const SQLITE_CONFIG_SQLLOG: i32 = 21; -pub const SQLITE_CONFIG_MMAP_SIZE: i32 = 22; -pub const SQLITE_CONFIG_WIN32_HEAPSIZE: i32 = 23; -pub const SQLITE_CONFIG_PCACHE_HDRSZ: i32 = 24; -pub const SQLITE_CONFIG_PMASZ: i32 = 25; -pub const SQLITE_CONFIG_STMTJRNL_SPILL: i32 = 26; -pub const SQLITE_DBCONFIG_MAINDBNAME: i32 = 1000; -pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; -pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; -pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; -pub const SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: i32 = 1004; -pub const SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: i32 = 1005; -pub const SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE: i32 = 1006; -pub const SQLITE_DBCONFIG_ENABLE_QPSG: i32 = 1007; -pub const SQLITE_DENY: i32 = 1; -pub const SQLITE_IGNORE: i32 = 2; -pub const SQLITE_CREATE_INDEX: i32 = 1; -pub const SQLITE_CREATE_TABLE: i32 = 2; -pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; -pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; -pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; -pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; -pub const SQLITE_CREATE_TRIGGER: i32 = 7; -pub const SQLITE_CREATE_VIEW: i32 = 8; -pub const SQLITE_DELETE: i32 = 9; -pub const SQLITE_DROP_INDEX: i32 = 10; -pub const SQLITE_DROP_TABLE: i32 = 11; -pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; -pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; -pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; -pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; -pub const SQLITE_DROP_TRIGGER: i32 = 16; -pub const SQLITE_DROP_VIEW: i32 = 17; -pub const SQLITE_INSERT: i32 = 18; -pub const SQLITE_PRAGMA: i32 = 19; -pub const SQLITE_READ: i32 = 20; -pub const SQLITE_SELECT: i32 = 21; -pub const SQLITE_TRANSACTION: i32 = 22; -pub const SQLITE_UPDATE: i32 = 23; -pub const SQLITE_ATTACH: i32 = 24; -pub const SQLITE_DETACH: i32 = 25; -pub const SQLITE_ALTER_TABLE: i32 = 26; -pub const SQLITE_REINDEX: i32 = 27; -pub const SQLITE_ANALYZE: i32 = 28; -pub const SQLITE_CREATE_VTABLE: i32 = 29; -pub const SQLITE_DROP_VTABLE: i32 = 30; -pub const SQLITE_FUNCTION: i32 = 31; -pub const SQLITE_SAVEPOINT: i32 = 32; -pub const SQLITE_COPY: i32 = 0; -pub const SQLITE_RECURSIVE: i32 = 33; -pub const SQLITE_TRACE_STMT: i32 = 1; -pub const SQLITE_TRACE_PROFILE: i32 = 2; -pub const SQLITE_TRACE_ROW: i32 = 4; -pub const SQLITE_TRACE_CLOSE: i32 = 8; -pub const SQLITE_LIMIT_LENGTH: i32 = 0; -pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; -pub const SQLITE_LIMIT_COLUMN: i32 = 2; -pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; -pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; -pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; -pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; -pub const SQLITE_LIMIT_ATTACHED: i32 = 7; -pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; -pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; -pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; -pub const SQLITE_LIMIT_WORKER_THREADS: i32 = 11; -pub const SQLITE_PREPARE_PERSISTENT: i32 = 1; -pub const SQLITE_INTEGER: i32 = 1; -pub const SQLITE_FLOAT: i32 = 2; -pub const SQLITE_BLOB: i32 = 4; -pub const SQLITE_NULL: i32 = 5; -pub const SQLITE_TEXT: i32 = 3; -pub const SQLITE3_TEXT: i32 = 3; -pub const SQLITE_UTF8: i32 = 1; -pub const SQLITE_UTF16LE: i32 = 2; -pub const SQLITE_UTF16BE: i32 = 3; -pub const SQLITE_UTF16: i32 = 4; -pub const SQLITE_ANY: i32 = 5; -pub const SQLITE_UTF16_ALIGNED: i32 = 8; -pub const SQLITE_DETERMINISTIC: i32 = 2048; -pub const SQLITE_INDEX_SCAN_UNIQUE: i32 = 1; -pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; -pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; -pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; -pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; -pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; -pub const SQLITE_INDEX_CONSTRAINT_LIKE: i32 = 65; -pub const SQLITE_INDEX_CONSTRAINT_GLOB: i32 = 66; -pub const SQLITE_INDEX_CONSTRAINT_REGEXP: i32 = 67; -pub const SQLITE_MUTEX_FAST: i32 = 0; -pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; -pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; -pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; -pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; -pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; -pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; -pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; -pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; -pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; -pub const SQLITE_MUTEX_STATIC_APP1: i32 = 8; -pub const SQLITE_MUTEX_STATIC_APP2: i32 = 9; -pub const SQLITE_MUTEX_STATIC_APP3: i32 = 10; -pub const SQLITE_MUTEX_STATIC_VFS1: i32 = 11; -pub const SQLITE_MUTEX_STATIC_VFS2: i32 = 12; -pub const SQLITE_MUTEX_STATIC_VFS3: i32 = 13; -pub const SQLITE_TESTCTRL_FIRST: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; -pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; -pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; -pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; -pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; -pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; -pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; -pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; -pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; -pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; -pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; -pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 17; -pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 18; -pub const SQLITE_TESTCTRL_EXPLAIN_STMT: i32 = 19; -pub const SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD: i32 = 19; -pub const SQLITE_TESTCTRL_NEVER_CORRUPT: i32 = 20; -pub const SQLITE_TESTCTRL_VDBE_COVERAGE: i32 = 21; -pub const SQLITE_TESTCTRL_BYTEORDER: i32 = 22; -pub const SQLITE_TESTCTRL_ISINIT: i32 = 23; -pub const SQLITE_TESTCTRL_SORTER_MMAP: i32 = 24; -pub const SQLITE_TESTCTRL_IMPOSTER: i32 = 25; -pub const SQLITE_TESTCTRL_LAST: i32 = 25; -pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; -pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; -pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; -pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; -pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; -pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; -pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; -pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; -pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; -pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; -pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; -pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; -pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; -pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; -pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; -pub const SQLITE_DBSTATUS_CACHE_HIT: i32 = 7; -pub const SQLITE_DBSTATUS_CACHE_MISS: i32 = 8; -pub const SQLITE_DBSTATUS_CACHE_WRITE: i32 = 9; -pub const SQLITE_DBSTATUS_DEFERRED_FKS: i32 = 10; -pub const SQLITE_DBSTATUS_CACHE_USED_SHARED: i32 = 11; -pub const SQLITE_DBSTATUS_MAX: i32 = 11; -pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; -pub const SQLITE_STMTSTATUS_SORT: i32 = 2; -pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; -pub const SQLITE_STMTSTATUS_VM_STEP: i32 = 4; -pub const SQLITE_STMTSTATUS_REPREPARE: i32 = 5; -pub const SQLITE_STMTSTATUS_RUN: i32 = 6; -pub const SQLITE_STMTSTATUS_MEMUSED: i32 = 99; -pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; -pub const SQLITE_CHECKPOINT_FULL: i32 = 1; -pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; -pub const SQLITE_CHECKPOINT_TRUNCATE: i32 = 3; -pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; -pub const SQLITE_ROLLBACK: i32 = 1; -pub const SQLITE_FAIL: i32 = 3; -pub const SQLITE_REPLACE: i32 = 5; -pub const SQLITE_SCANSTAT_NLOOP: i32 = 0; -pub const SQLITE_SCANSTAT_NVISIT: i32 = 1; -pub const SQLITE_SCANSTAT_EST: i32 = 2; -pub const SQLITE_SCANSTAT_NAME: i32 = 3; -pub const SQLITE_SCANSTAT_EXPLAIN: i32 = 4; -pub const SQLITE_SCANSTAT_SELECTID: i32 = 5; -pub const NOT_WITHIN: i32 = 0; -pub const PARTLY_WITHIN: i32 = 1; -pub const FULLY_WITHIN: i32 = 2; -pub const FTS5_TOKENIZE_QUERY: i32 = 1; -pub const FTS5_TOKENIZE_PREFIX: i32 = 2; -pub const FTS5_TOKENIZE_DOCUMENT: i32 = 4; -pub const FTS5_TOKENIZE_AUX: i32 = 8; -pub const FTS5_TOKEN_COLOCATED: i32 = 1; -pub type va_list = __builtin_va_list; -pub type __gnuc_va_list = __builtin_va_list; -extern "C" { - #[link_name = "\u{1}sqlite3_version"] - pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3 { - _unused: [u8; 0], -} -pub type sqlite_int64 = ::std::os::raw::c_longlong; -pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; -pub type sqlite3_int64 = sqlite_int64; -pub type sqlite3_uint64 = sqlite_uint64; -pub type sqlite3_callback = ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_file { - pub pMethods: *const sqlite3_io_methods, -} -#[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_file)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_file)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_file), - "::", - stringify!(pMethods) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_io_methods { - pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xRead: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *mut ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xWrite: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *const ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pSize: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xUnlock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCheckReservedLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileControl: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - op: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xSectorSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xDeviceCharacteristics: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xShmMap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iPg: ::std::os::raw::c_int, - pgsz: ::std::os::raw::c_int, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xShmLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - offset: ::std::os::raw::c_int, - n: ::std::os::raw::c_int, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xShmBarrier: ::std::option::Option, - pub xShmUnmap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - deleteFlag: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iOfst: sqlite3_int64, - iAmt: ::std::os::raw::c_int, - pp: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xUnfetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iOfst: sqlite3_int64, - p: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_io_methods() { - assert_eq!( - ::std::mem::size_of::(), - 152usize, - concat!("Size of: ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xRead) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xWrite) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnlock) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xCheckReservedLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileControl) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSectorSize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ - as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xDeviceCharacteristics) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmMap) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmBarrier) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmUnmap) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnfetch as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnfetch) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex { - _unused: [u8; 0], -} -pub type sqlite3_syscall_ptr = ::std::option::Option; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vfs { - pub iVersion: ::std::os::raw::c_int, - pub szOsFile: ::std::os::raw::c_int, - pub mxPathname: ::std::os::raw::c_int, - pub pNext: *mut sqlite3_vfs, - pub zName: *const ::std::os::raw::c_char, - pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - pOutFlags: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - syncDir: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xAccess: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - flags: ::std::os::raw::c_int, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFullPathname: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - nOut: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xDlOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zFilename: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void, - >, - pub xDlError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zErrMsg: *mut ::std::os::raw::c_char, - ), - >, - pub xDlSym: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ) -> ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ), - >, - >, - pub xDlClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), - >, - pub xRandomness: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSleep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - microseconds: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTime: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, - >, - pub xGetLastError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTimeInt64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xSetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: sqlite3_syscall_ptr, - ) -> ::std::os::raw::c_int, - >, - pub xGetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> sqlite3_syscall_ptr, - >, - pub xNextSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!( - ::std::mem::size_of::(), - 168usize, - concat!("Size of: ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(szOsFile) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(mxPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(zName) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pAppData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xAccess) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xFullPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlSym) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xRandomness) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSleep) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTime) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetLastError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTimeInt64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xNextSystemCall) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xRoundup: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub pAppData: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!( - ::std::mem::size_of::(), - 64usize, - concat!("Size of: ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xMalloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xFree) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRealloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRoundup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(pAppData) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_value { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_context { - _unused: [u8; 0], -} -pub type sqlite3_destructor_type = - ::std::option::Option; -extern "C" { - #[link_name = "\u{1}sqlite3_temp_directory"] - pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; -} -extern "C" { - #[link_name = "\u{1}sqlite3_data_directory"] - pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xConnect: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xBestIndex: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: *mut sqlite3_index_info, - ) -> ::std::os::raw::c_int, - >, - pub xDisconnect: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xDestroy: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - ppCursor: *mut *mut sqlite3_vtab_cursor, - ) -> ::std::os::raw::c_int, - >, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xFilter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - idxNum: ::std::os::raw::c_int, - idxStr: *const ::std::os::raw::c_char, - argc: ::std::os::raw::c_int, - argv: *mut *mut sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub xNext: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xEof: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - arg2: *mut sqlite3_context, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - pRowid: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xUpdate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - arg4: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xBegin: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xCommit: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xRollback: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xFindFunction: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - nArg: ::std::os::raw::c_int, - zName: *const ::std::os::raw::c_char, - pxFunc: *mut ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - ppArg: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xRename: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - zNew: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSavepoint: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRelease: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRollbackTo: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!( - ::std::mem::size_of::(), - 184usize, - concat!("Size of: ", stringify!(sqlite3_module)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_module)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xConnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBestIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDisconnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFilter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xEof) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xColumn) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xUpdate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBegin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCommit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollback) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFindFunction) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRename) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSavepoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRelease) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollbackTo) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info { - pub nConstraint: ::std::os::raw::c_int, - pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, - pub nOrderBy: ::std::os::raw::c_int, - pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, - pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, - pub idxNum: ::std::os::raw::c_int, - pub idxStr: *mut ::std::os::raw::c_char, - pub needToFreeIdxStr: ::std::os::raw::c_int, - pub orderByConsumed: ::std::os::raw::c_int, - pub estimatedCost: f64, - pub estimatedRows: sqlite3_int64, - pub idxFlags: ::std::os::raw::c_int, - pub colUsed: sqlite3_uint64, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint { - pub iColumn: ::std::os::raw::c_int, - pub op: ::std::os::raw::c_uchar, - pub usable: ::std::os::raw::c_uchar, - pub iTermOffset: ::std::os::raw::c_int, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).op as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(op) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).usable - as *const _ as usize - }, - 5usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(usable) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iTermOffset - as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iTermOffset) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_orderby { - pub iColumn: ::std::os::raw::c_int, - pub desc: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).desc as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(desc) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint_usage { - pub argvIndex: ::std::os::raw::c_int, - pub omit: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).argvIndex - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(argvIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).omit - as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(omit) - ) - ); -} -#[test] -fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!( - ::std::mem::size_of::(), - 96usize, - concat!("Size of: ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nOrderBy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aOrderBy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraintUsage) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxNum) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(needToFreeIdxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(orderByConsumed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedCost as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedCost) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedRows as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedRows) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxFlags as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxFlags) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).colUsed as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(colUsed) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(pModule) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(nRef) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(zErrMsg) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab_cursor { - pub pVtab: *mut sqlite3_vtab, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab_cursor), - "::", - stringify!(pVtab) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexNotheld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexInit as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnd) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexAlloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexFree as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexFree) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexTry) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexLeave) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexHeld) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexNotheld) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_page { - pub pBuf: *mut ::std::os::raw::c_void, - pub pExtra: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_page() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(sqlite3_pcache_page)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_page)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_page), - "::", - stringify!(pBuf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_page), - "::", - stringify!(pExtra) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods2 { - pub iVersion: ::std::os::raw::c_int, - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - szExtra: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache_page, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut sqlite3_pcache_page, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut sqlite3_pcache_page, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, - pub xShrink: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods2() { - assert_eq!( - ::std::mem::size_of::(), - 104usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iVersion as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDestroy as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xShrink) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods { - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!( - ::std::mem::size_of::(), - 88usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xDestroy) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_backup { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct sqlite3_snapshot { - pub hidden: [::std::os::raw::c_uchar; 48usize], -} -#[test] -fn bindgen_test_layout_sqlite3_snapshot() { - assert_eq!( - ::std::mem::size_of::(), - 48usize, - concat!("Size of: ", stringify!(sqlite3_snapshot)) - ); - assert_eq!( - ::std::mem::align_of::(), - 1usize, - concat!("Alignment of ", stringify!(sqlite3_snapshot)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).hidden as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_snapshot), - "::", - stringify!(hidden) - ) - ); -} -pub type sqlite3_rtree_dbl = f64; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_rtree_geometry { - pub pContext: *mut ::std::os::raw::c_void, - pub nParam: ::std::os::raw::c_int, - pub aParam: *mut sqlite3_rtree_dbl, - pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_rtree_geometry() { - assert_eq!( - ::std::mem::size_of::(), - 40usize, - concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pContext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(nParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(aParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pUser) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(xDelUser) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_rtree_query_info { - pub pContext: *mut ::std::os::raw::c_void, - pub nParam: ::std::os::raw::c_int, - pub aParam: *mut sqlite3_rtree_dbl, - pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, - pub aCoord: *mut sqlite3_rtree_dbl, - pub anQueue: *mut ::std::os::raw::c_uint, - pub nCoord: ::std::os::raw::c_int, - pub iLevel: ::std::os::raw::c_int, - pub mxLevel: ::std::os::raw::c_int, - pub iRowid: sqlite3_int64, - pub rParentScore: sqlite3_rtree_dbl, - pub eParentWithin: ::std::os::raw::c_int, - pub eWithin: ::std::os::raw::c_int, - pub rScore: sqlite3_rtree_dbl, - pub apSqlParam: *mut *mut sqlite3_value, -} -#[test] -fn bindgen_test_layout_sqlite3_rtree_query_info() { - assert_eq!( - ::std::mem::size_of::(), - 112usize, - concat!("Size of: ", stringify!(sqlite3_rtree_query_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_rtree_query_info)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).pContext as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(pContext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(nParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(aParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(pUser) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDelUser as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(xDelUser) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aCoord as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(aCoord) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).anQueue as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(anQueue) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nCoord as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(nCoord) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iLevel as *const _ as usize }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(iLevel) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mxLevel as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(mxLevel) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iRowid as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(iRowid) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rParentScore as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(rParentScore) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).eParentWithin as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(eParentWithin) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).eWithin as *const _ as usize - }, - 92usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(eWithin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).rScore as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(rScore) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).apSqlParam as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(apSqlParam) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5Context { - _unused: [u8; 0], -} -pub type fts5_extension_function = ::std::option::Option< - unsafe extern "C" fn( - pApi: *const Fts5ExtensionApi, - pFts: *mut Fts5Context, - pCtx: *mut sqlite3_context, - nVal: ::std::os::raw::c_int, - apVal: *mut *mut sqlite3_value, - ), ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5PhraseIter { - pub a: *const ::std::os::raw::c_uchar, - pub b: *const ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_Fts5PhraseIter() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(Fts5PhraseIter)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Fts5PhraseIter)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).a as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Fts5PhraseIter), - "::", - stringify!(a) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).b as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Fts5PhraseIter), - "::", - stringify!(b) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5ExtensionApi { - pub iVersion: ::std::os::raw::c_int, - pub xUserData: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> *mut ::std::os::raw::c_void, - >, - pub xColumnCount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, - >, - pub xRowCount: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pnRow: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xColumnTotalSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pnToken: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTokenize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pText: *const ::std::os::raw::c_char, - nText: ::std::os::raw::c_int, - pCtx: *mut ::std::os::raw::c_void, - xToken: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, - arg6: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseCount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, - >, - pub xPhraseSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xInstCount: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pnInst: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xInst: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iIdx: ::std::os::raw::c_int, - piPhrase: *mut ::std::os::raw::c_int, - piCol: *mut ::std::os::raw::c_int, - piOff: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: - ::std::option::Option sqlite3_int64>, - pub xColumnText: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pz: *mut *const ::std::os::raw::c_char, - pn: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xColumnSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pnToken: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xQueryPhrase: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - pUserData: *mut ::std::os::raw::c_void, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const Fts5ExtensionApi, - arg2: *mut Fts5Context, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub xSetAuxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pAux: *mut ::std::os::raw::c_void, - xDelete: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub xGetAuxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - bClear: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xPhraseFirst: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - arg2: *mut Fts5PhraseIter, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseNext: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - arg2: *mut Fts5PhraseIter, - piCol: *mut ::std::os::raw::c_int, - piOff: *mut ::std::os::raw::c_int, - ), - >, - pub xPhraseFirstColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - arg2: *mut Fts5PhraseIter, - arg3: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseNextColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - arg2: *mut Fts5PhraseIter, - piCol: *mut ::std::os::raw::c_int, - ), - >, -} -#[test] -fn bindgen_test_layout_Fts5ExtensionApi() { - assert_eq!( - ::std::mem::size_of::(), - 160usize, - concat!("Size of: ", stringify!(Fts5ExtensionApi)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Fts5ExtensionApi)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUserData as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xUserData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnCount as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowCount as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xRowCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xColumnTotalSize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnTotalSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xTokenize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseCount as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseSize as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInstCount as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xInstCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInst as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xInst) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnText as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnText) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnSize as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xQueryPhrase as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xQueryPhrase) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSetAuxdata as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xSetAuxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetAuxdata as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xGetAuxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseFirst as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseFirst) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseNext as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseNext) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPhraseFirstColumn as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseFirstColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPhraseNextColumn as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseNextColumn) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5Tokenizer { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct fts5_tokenizer { - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - azArg: *mut *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ppOut: *mut *mut Fts5Tokenizer, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option, - pub xTokenize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Tokenizer, - pCtx: *mut ::std::os::raw::c_void, - flags: ::std::os::raw::c_int, - pText: *const ::std::os::raw::c_char, - nText: ::std::os::raw::c_int, - xToken: ::std::option::Option< - unsafe extern "C" fn( - pCtx: *mut ::std::os::raw::c_void, - tflags: ::std::os::raw::c_int, - pToken: *const ::std::os::raw::c_char, - nToken: ::std::os::raw::c_int, - iStart: ::std::os::raw::c_int, - iEnd: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_fts5_tokenizer() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(fts5_tokenizer)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(fts5_tokenizer)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xTokenize) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct fts5_api { - pub iVersion: ::std::os::raw::c_int, - pub xCreateTokenizer: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - pContext: *mut ::std::os::raw::c_void, - pTokenizer: *mut fts5_tokenizer, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub xFindTokenizer: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - ppContext: *mut *mut ::std::os::raw::c_void, - pTokenizer: *mut fts5_tokenizer, - ) -> ::std::os::raw::c_int, - >, - pub xCreateFunction: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - pContext: *mut ::std::os::raw::c_void, - xFunction: fts5_extension_function, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_fts5_api() { - assert_eq!( - ::std::mem::size_of::(), - 32usize, - concat!("Size of: ", stringify!(fts5_api)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(fts5_api)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreateTokenizer as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xCreateTokenizer) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindTokenizer as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xFindTokenizer) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreateFunction as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xCreateFunction) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_api_routines { - pub aggregate_context: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub aggregate_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, - >, - pub bind_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_double: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, - ) -> ::std::os::raw::c_int, - >, - pub bind_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_int64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, - ) -> ::std::os::raw::c_int, - >, - pub bind_null: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub bind_parameter_index: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub bind_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub busy_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub busy_timeout: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub changes: - ::std::option::Option ::std::os::raw::c_int>, - pub close: - ::std::option::Option ::std::os::raw::c_int>, - pub collation_needed: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub collation_needed16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub column_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_bytes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_bytes16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub column_database_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_database_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_decltype: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_decltype16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_double: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, - >, - pub column_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_int64: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, - >, - pub column_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_origin_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_origin_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_table_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_table_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_uchar, - >, - pub column_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_type: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *mut sqlite3_value, - >, - pub commit_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub complete: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, - pub complete16: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub create_collation: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_collation16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_function16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_module: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub data_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub db_handle: - ::std::option::Option *mut sqlite3>, - pub declare_vtab: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub enable_shared_cache: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub errcode: - ::std::option::Option ::std::os::raw::c_int>, - pub errmsg: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, - >, - pub errmsg16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, - >, - pub exec: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub expired: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub finalize: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub free: ::std::option::Option, - pub free_table: - ::std::option::Option, - pub get_autocommit: - ::std::option::Option ::std::os::raw::c_int>, - pub get_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub get_table: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub global_recover: ::std::option::Option ::std::os::raw::c_int>, - pub interruptx: ::std::option::Option, - pub last_insert_rowid: - ::std::option::Option sqlite_int64>, - pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, - pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, - pub malloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub mprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub open16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub prepare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub profile: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub progress_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, - ), - >, - pub realloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub reset: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub result_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_double: - ::std::option::Option, - pub result_error: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_error16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_int64: - ::std::option::Option, - pub result_null: ::std::option::Option, - pub result_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16be: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16le: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_value: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), - >, - pub rollback_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub set_authorizer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub set_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, - ), - >, - pub snprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub step: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub table_column_metadata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub thread_cleanup: ::std::option::Option, - pub total_changes: - ::std::option::Option ::std::os::raw::c_int>, - pub trace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub transfer_bindings: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, - ) -> ::std::os::raw::c_int, - >, - pub update_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub user_data: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, - >, - pub value_blob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_bytes16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_double: ::std::option::Option f64>, - pub value_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_int64: - ::std::option::Option sqlite_int64>, - pub value_numeric_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_text: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, - >, - pub value_text16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16be: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16le: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub vmprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char, - >, - pub overload_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub prepare_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub clear_bindings: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub create_module_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_zeroblob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_close: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, - ) -> ::std::os::raw::c_int, - >, - pub blob_read: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_write: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub create_collation_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub file_control: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub memory_highwater: - ::std::option::Option sqlite3_int64>, - pub memory_used: ::std::option::Option sqlite3_int64>, - pub mutex_alloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub mutex_enter: ::std::option::Option, - pub mutex_free: ::std::option::Option, - pub mutex_leave: ::std::option::Option, - pub mutex_try: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub open_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub release_memory: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub result_error_nomem: ::std::option::Option, - pub result_error_toobig: - ::std::option::Option, - pub sleep: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub soft_heap_limit: ::std::option::Option, - pub vfs_find: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, - >, - pub vfs_register: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub vfs_unregister: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, - >, - pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, - pub result_zeroblob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_error_code: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub test_control: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, - >, - pub randomness: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), - >, - pub context_db_handle: - ::std::option::Option *mut sqlite3>, - pub extended_result_codes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub limit: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub next_stmt: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, - >, - pub sql: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, - >, - pub status: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub backup_finish: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_init: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut sqlite3, - arg4: *const ::std::os::raw::c_char, - ) -> *mut sqlite3_backup, - >, - pub backup_pagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_remaining: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_step: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_backup, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub compileoption_get: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, - >, - pub compileoption_used: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, - pub create_function_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub db_config: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int, - >, - pub db_mutex: - ::std::option::Option *mut sqlite3_mutex>, - pub db_status: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub extended_errcode: - ::std::option::Option ::std::os::raw::c_int>, - pub log: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char, ...), - >, - pub soft_heap_limit64: - ::std::option::Option sqlite3_int64>, - pub sourceid: ::std::option::Option *const ::std::os::raw::c_char>, - pub stmt_status: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub strnicmp: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub unlock_notify: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub wal_autocheckpoint: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub wal_checkpoint: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub wal_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub blob_reopen: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob, arg2: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub vtab_config: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int, - >, - pub vtab_on_conflict: - ::std::option::Option ::std::os::raw::c_int>, - pub close_v2: - ::std::option::Option ::std::os::raw::c_int>, - pub db_filename: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, - pub db_readonly: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub db_release_memory: - ::std::option::Option ::std::os::raw::c_int>, - pub errstr: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, - >, - pub stmt_busy: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub stmt_readonly: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub stricmp: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub uri_boolean: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub uri_int64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_int64, - ) -> sqlite3_int64, - >, - pub uri_parameter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, - pub vsnprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char, - >, - pub wal_checkpoint_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub auto_extension: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_blob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_text64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - arg6: ::std::os::raw::c_uchar, - ) -> ::std::os::raw::c_int, - >, - pub cancel_auto_extension: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub load_extension: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub malloc64: ::std::option::Option< - unsafe extern "C" fn(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void, - >, - pub msize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64, - >, - pub realloc64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: sqlite3_uint64, - ) -> *mut ::std::os::raw::c_void, - >, - pub reset_auto_extension: ::std::option::Option, - pub result_blob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - ), - >, - pub result_text64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - arg5: ::std::os::raw::c_uchar, - ), - >, - pub strglob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub value_dup: ::std::option::Option< - unsafe extern "C" fn(arg1: *const sqlite3_value) -> *mut sqlite3_value, - >, - pub value_free: ::std::option::Option, - pub result_zeroblob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: sqlite3_uint64, - ) -> ::std::os::raw::c_int, - >, - pub bind_zeroblob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_uint64, - ) -> ::std::os::raw::c_int, - >, - pub value_subtype: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint, - >, - pub result_subtype: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint), - >, - pub status64: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut sqlite3_int64, - arg3: *mut sqlite3_int64, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub strlike: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_uint, - ) -> ::std::os::raw::c_int, - >, - pub db_cacheflush: - ::std::option::Option ::std::os::raw::c_int>, - pub system_errno: - ::std::option::Option ::std::os::raw::c_int>, - pub trace_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_uint, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_uint, - arg2: *mut ::std::os::raw::c_void, - arg3: *mut ::std::os::raw::c_void, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub expanded_sql: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char, - >, - pub set_last_insert_rowid: - ::std::option::Option, - pub prepare_v3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_uint, - arg5: *mut *mut sqlite3_stmt, - arg6: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16_v3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_uint, - arg5: *mut *mut sqlite3_stmt, - arg6: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub bind_pointer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: *const ::std::os::raw::c_char, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub result_pointer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *mut ::std::os::raw::c_void, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::option::Option, - ), - >, - pub value_pointer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_value, - arg2: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_api_routines() { - assert_eq!( - ::std::mem::size_of::(), - 1776usize, - concat!("Size of: ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_context as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_context) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_count as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_double as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_count as *const _ - as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_index as *const _ - as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_index) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_name as *const _ - as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_text16 as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_handler as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_handler) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_timeout as *const _ as usize - }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_timeout) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(close) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed as *const _ as usize - }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_blob as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes as *const _ as usize - }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize - }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_count as *const _ as usize - }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name as *const _ - as usize - }, - 184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name16 as *const _ - as usize - }, - 192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype as *const _ as usize - }, - 200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize - }, - 208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_double as *const _ as usize - }, - 216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, - 224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_int64 as *const _ as usize - }, - 232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name as *const _ as usize - }, - 240usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name16 as *const _ as usize - }, - 248usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name as *const _ as usize - }, - 256usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name16 as *const _ - as usize - }, - 264usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name as *const _ as usize - }, - 272usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name16 as *const _ - as usize - }, - 280usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text as *const _ as usize - }, - 288usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text16 as *const _ as usize - }, - 296usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_type as *const _ as usize - }, - 304usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_type) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_value as *const _ as usize - }, - 312usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).commit_hook as *const _ as usize - }, - 320usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(commit_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, - 328usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, - 336usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation as *const _ as usize - }, - 344usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation16 as *const _ as usize - }, - 352usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function as *const _ as usize - }, - 360usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function16 as *const _ as usize - }, - 368usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module as *const _ as usize - }, - 376usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, - 384usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(data_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, - 392usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).declare_vtab as *const _ as usize - }, - 400usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(declare_vtab) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).enable_shared_cache as *const _ - as usize - }, - 408usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(enable_shared_cache) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, - 416usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, - 424usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, - 432usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, - 440usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(exec) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, - 448usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(expired) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, - 456usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(finalize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, - 464usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, - 472usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_autocommit as *const _ as usize - }, - 480usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_autocommit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_auxdata as *const _ as usize - }, - 488usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, - 496usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).global_recover as *const _ as usize - }, - 504usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(global_recover) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, - 512usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(interruptx) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize - }, - 520usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(last_insert_rowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, - 528usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).libversion_number as *const _ as usize - }, - 536usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion_number) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, - 544usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(malloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, - 552usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, - 560usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, - 568usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, - 576usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, - 584usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, - 592usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(profile) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).progress_handler as *const _ as usize - }, - 600usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(progress_handler) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, - 608usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(realloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, - 616usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(reset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_blob as *const _ as usize - }, - 624usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_double as *const _ as usize - }, - 632usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_double) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error as *const _ as usize - }, - 640usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error16 as *const _ as usize - }, - 648usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, - 656usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_int64 as *const _ as usize - }, - 664usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_null as *const _ as usize - }, - 672usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text as *const _ as usize - }, - 680usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16 as *const _ as usize - }, - 688usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16be as *const _ as usize - }, - 696usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16le as *const _ as usize - }, - 704usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16le) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_value as *const _ as usize - }, - 712usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rollback_hook as *const _ as usize - }, - 720usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(rollback_hook) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_authorizer as *const _ as usize - }, - 728usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_authorizer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_auxdata as *const _ as usize - }, - 736usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).snprintf as *const _ as usize }, - 744usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(snprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, - 752usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(step) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).table_column_metadata as *const _ - as usize - }, - 760usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(table_column_metadata) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize - }, - 768usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(thread_cleanup) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).total_changes as *const _ as usize - }, - 776usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(total_changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, - 784usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(trace) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize - }, - 792usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(transfer_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).update_hook as *const _ as usize - }, - 800usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(update_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, - 808usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(user_data) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, - 816usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes as *const _ as usize - }, - 824usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize - }, - 832usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_double as *const _ as usize - }, - 840usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, - 848usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_int64 as *const _ as usize - }, - 856usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize - }, - 864usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_numeric_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, - 872usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16 as *const _ as usize - }, - 880usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16be as *const _ as usize - }, - 888usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16le as *const _ as usize - }, - 896usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16le) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, - 904usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, - 912usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vmprintf) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).overload_function as *const _ as usize - }, - 920usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(overload_function) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, - 928usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize - }, - 936usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).clear_bindings as *const _ as usize - }, - 944usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(clear_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize - }, - 952usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize - }, - 960usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_zeroblob) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, - 968usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_bytes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, - 976usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_close) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, - 984usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, - 992usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_read) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, - 1000usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_write) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation_v2 as *const _ - as usize - }, - 1008usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).file_control as *const _ as usize - }, - 1016usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(file_control) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_highwater as *const _ as usize - }, - 1024usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_highwater) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_used as *const _ as usize - }, - 1032usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_used) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize - }, - 1040usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_alloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_enter as *const _ as usize - }, - 1048usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_enter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, - 1056usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_free) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_leave as *const _ as usize - }, - 1064usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_leave) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, - 1072usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_try) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, - 1080usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).release_memory as *const _ as usize - }, - 1088usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(release_memory) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize - }, - 1096usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_nomem) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_toobig as *const _ - as usize - }, - 1104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_toobig) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, - 1112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sleep) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize - }, - 1120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(soft_heap_limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, - 1128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_find) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_register as *const _ as usize - }, - 1136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_register) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize - }, - 1144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_unregister) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize - }, - 1152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(xthreadsafe) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize - }, - 1160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_zeroblob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_code as *const _ as usize - }, - 1168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_code) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).test_control as *const _ as usize - }, - 1176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(test_control) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, - 1184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(randomness) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).context_db_handle as *const _ as usize - }, - 1192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(context_db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).extended_result_codes as *const _ - as usize - }, - 1200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(extended_result_codes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, - 1208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, - 1216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(next_stmt) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, - 1224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sql) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, - 1232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(status) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_finish as *const _ as usize - }, - 1240usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_finish) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_init as *const _ as usize - }, - 1248usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_init) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_pagecount as *const _ as usize - }, - 1256usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_pagecount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_remaining as *const _ as usize - }, - 1264usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_remaining) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_step as *const _ as usize - }, - 1272usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_step) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).compileoption_get as *const _ as usize - }, - 1280usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(compileoption_get) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).compileoption_used as *const _ as usize - }, - 1288usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(compileoption_used) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function_v2 as *const _ as usize - }, - 1296usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function_v2) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_config as *const _ as usize }, - 1304usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_config) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_mutex as *const _ as usize }, - 1312usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_mutex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_status as *const _ as usize }, - 1320usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_status) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).extended_errcode as *const _ as usize - }, - 1328usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(extended_errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).log as *const _ as usize }, - 1336usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(log) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).soft_heap_limit64 as *const _ as usize - }, - 1344usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(soft_heap_limit64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sourceid as *const _ as usize }, - 1352usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sourceid) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stmt_status as *const _ as usize - }, - 1360usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_status) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).strnicmp as *const _ as usize }, - 1368usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(strnicmp) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).unlock_notify as *const _ as usize - }, - 1376usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(unlock_notify) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_autocheckpoint as *const _ as usize - }, - 1384usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_autocheckpoint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_checkpoint as *const _ as usize - }, - 1392usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_checkpoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).wal_hook as *const _ as usize }, - 1400usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_hook) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).blob_reopen as *const _ as usize - }, - 1408usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_reopen) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtab_config as *const _ as usize - }, - 1416usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vtab_config) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtab_on_conflict as *const _ as usize - }, - 1424usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vtab_on_conflict) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).close_v2 as *const _ as usize }, - 1432usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(close_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_filename as *const _ as usize - }, - 1440usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_filename) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_readonly as *const _ as usize - }, - 1448usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_readonly) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_release_memory as *const _ as usize - }, - 1456usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_release_memory) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errstr as *const _ as usize }, - 1464usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errstr) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).stmt_busy as *const _ as usize }, - 1472usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_busy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stmt_readonly as *const _ as usize - }, - 1480usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_readonly) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).stricmp as *const _ as usize }, - 1488usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stricmp) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).uri_boolean as *const _ as usize - }, - 1496usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(uri_boolean) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).uri_int64 as *const _ as usize }, - 1504usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(uri_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).uri_parameter as *const _ as usize - }, - 1512usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(uri_parameter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vsnprintf as *const _ as usize }, - 1520usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vsnprintf) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_checkpoint_v2 as *const _ as usize - }, - 1528usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_checkpoint_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).auto_extension as *const _ as usize - }, - 1536usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(auto_extension) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_blob64 as *const _ as usize - }, - 1544usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_blob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_text64 as *const _ as usize - }, - 1552usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).cancel_auto_extension as *const _ - as usize - }, - 1560usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(cancel_auto_extension) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).load_extension as *const _ as usize - }, - 1568usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(load_extension) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).malloc64 as *const _ as usize }, - 1576usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(malloc64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).msize as *const _ as usize }, - 1584usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(msize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).realloc64 as *const _ as usize }, - 1592usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(realloc64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).reset_auto_extension as *const _ - as usize - }, - 1600usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(reset_auto_extension) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_blob64 as *const _ as usize - }, - 1608usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_blob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text64 as *const _ as usize - }, - 1616usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).strglob as *const _ as usize }, - 1624usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(strglob) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_dup as *const _ as usize }, - 1632usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_dup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_free as *const _ as usize }, - 1640usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_free) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_zeroblob64 as *const _ as usize - }, - 1648usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_zeroblob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_zeroblob64 as *const _ as usize - }, - 1656usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_zeroblob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_subtype as *const _ as usize - }, - 1664usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_subtype) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_subtype as *const _ as usize - }, - 1672usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_subtype) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).status64 as *const _ as usize }, - 1680usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(status64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).strlike as *const _ as usize }, - 1688usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(strlike) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_cacheflush as *const _ as usize - }, - 1696usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_cacheflush) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).system_errno as *const _ as usize - }, - 1704usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(system_errno) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).trace_v2 as *const _ as usize }, - 1712usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(trace_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).expanded_sql as *const _ as usize - }, - 1720usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(expanded_sql) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_last_insert_rowid as *const _ - as usize - }, - 1728usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_last_insert_rowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare_v3 as *const _ as usize }, - 1736usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare_v3) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).prepare16_v3 as *const _ as usize - }, - 1744usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16_v3) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_pointer as *const _ as usize - }, - 1752usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_pointer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_pointer as *const _ as usize - }, - 1760usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_pointer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_pointer as *const _ as usize - }, - 1768usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_pointer) - ) - ); -} -pub type sqlite3_loadext_entry = ::std::option::Option< - unsafe extern "C" fn( - db: *mut sqlite3, - pzErrMsg: *mut *mut ::std::os::raw::c_char, - pThunk: *const sqlite3_api_routines, - ) -> ::std::os::raw::c_int, ->; -pub type __builtin_va_list = [__va_list_tag; 1usize]; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct __va_list_tag { - pub gp_offset: ::std::os::raw::c_uint, - pub fp_offset: ::std::os::raw::c_uint, - pub overflow_arg_area: *mut ::std::os::raw::c_void, - pub reg_save_area: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout___va_list_tag() { - assert_eq!( - ::std::mem::size_of::<__va_list_tag>(), - 24usize, - concat!("Size of: ", stringify!(__va_list_tag)) - ); - assert_eq!( - ::std::mem::align_of::<__va_list_tag>(), - 8usize, - concat!("Alignment of ", stringify!(__va_list_tag)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(gp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(fp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(overflow_arg_area) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(reg_save_area) - ) - ); -} - -// bindings were built with loadable_extension_embedded: -// define sqlite3_api as an extern since this code will be embedded -// within a loadable extension that defines and exports this itself -extern "C" { - #[no_mangle] - pub static mut sqlite3_api: *mut sqlite3_api_routines; -} - -// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) - -pub unsafe fn sqlite3_aggregate_context( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_context.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_context", - " function" - )))(arg1, nBytes) -} - -pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_blob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_blob", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_double( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_double", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_null( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_null", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_parameter_index( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_index.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_index", - " function" - )))(arg1, zName) -} - -pub unsafe fn sqlite3_bind_parameter_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_text( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_text16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_bind_value( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_value", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_handler( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_handler", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_timeout( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_timeout.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_timeout", - " function" - )))(arg1, ms) -} - -pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_collation_needed( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_collation_needed16( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_column_blob( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_blob", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_column_database_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_database_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_decltype( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype", - " function" - )))(arg1, i) -} - -pub unsafe fn sqlite3_column_decltype16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_double", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int64( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int64", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_text( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_text16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_type( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_type", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_value( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_value", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_commit_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).commit_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "commit_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete16", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_create_collation( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_collation16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_function( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_function16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function16", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_module( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).data_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "data_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_declare_vtab( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).declare_vtab.expect(stringify!( - "sqlite3_api contains null pointer for ", - "declare_vtab", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).enable_shared_cache.expect(stringify!( - "sqlite3_api contains null pointer for ", - "enable_shared_cache", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errcode", - " function" - )))(db) -} - -pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_exec( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).exec.expect(stringify!( - "sqlite3_api contains null pointer for ", - "exec", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).expired.expect(stringify!( - "sqlite3_api contains null pointer for ", - "expired", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).finalize.expect(stringify!( - "sqlite3_api contains null pointer for ", - "finalize", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free_table", - " function" - )))(result) -} - -pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_autocommit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_autocommit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_get_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_auxdata", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_get_table( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_table", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).global_recover.expect(stringify!( - "sqlite3_api contains null pointer for ", - "global_recover", - " function" - )))() -} - -pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).interruptx.expect(stringify!( - "sqlite3_api contains null pointer for ", - "interruptx", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).last_insert_rowid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "last_insert_rowid", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion", - " function" - )))() -} - -pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion_number.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion_number", - " function" - )))() -} - -pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).malloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "malloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mprintf( - arg1: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mprintf", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_open( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_open16( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_prepare( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_profile( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).profile.expect(stringify!( - "sqlite3_api contains null pointer for ", - "profile", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_progress_handler( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).progress_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "progress_handler", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_realloc( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).realloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "realloc", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).reset.expect(stringify!( - "sqlite3_api contains null pointer for ", - "reset", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_result_blob( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_blob", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_double", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_error16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_null", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_text( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16be( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16be", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16le( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16le", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_value", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_rollback_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).rollback_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "rollback_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_authorizer( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_authorizer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_authorizer", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_auxdata", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_snprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).snprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "snprintf", - " function" - )))(arg1, arg2, arg3, vararg1) -} - -pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).step.expect(stringify!( - "sqlite3_api contains null pointer for ", - "step", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_table_column_metadata( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).table_column_metadata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "table_column_metadata", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) -} - -pub unsafe fn sqlite3_thread_cleanup() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).thread_cleanup.expect(stringify!( - "sqlite3_api contains null pointer for ", - "thread_cleanup", - " function" - )))() -} - -pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).total_changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "total_changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_trace( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).trace.expect(stringify!( - "sqlite3_api contains null pointer for ", - "trace", - " function" - )))(arg1, xTrace, arg2) -} - -pub unsafe fn sqlite3_transfer_bindings( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).transfer_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "transfer_bindings", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_update_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).update_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "update_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).user_data.expect(stringify!( - "sqlite3_api contains null pointer for ", - "user_data", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_blob", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_double", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_numeric_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_numeric_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16be", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16le", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vmprintf( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vmprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vmprintf", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_overload_function( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).overload_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "overload_function", - " function" - )))(arg1, zFuncName, nArg) -} - -pub unsafe fn sqlite3_prepare_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).clear_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "clear_bindings", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_module_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module_v2", - " function" - )))(arg1, arg2, arg3, arg4, xDestroy) -} - -pub unsafe fn sqlite3_bind_zeroblob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_zeroblob", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_open( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_open", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) -} - -pub unsafe fn sqlite3_blob_read( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_read.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_read", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_blob_write( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_write.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_write", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_create_collation_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_file_control( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).file_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "file_control", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_highwater.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_highwater", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_used.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_used", - " function" - )))() -} - -pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_alloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_alloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_enter.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_enter", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_leave.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_leave", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_try.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_try", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_open_v2( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open_v2", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).release_memory.expect(stringify!( - "sqlite3_api contains null pointer for ", - "release_memory", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_nomem.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_nomem", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_toobig.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_toobig", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sleep.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sleep", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).soft_heap_limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "soft_heap_limit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_find.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_find", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_register( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_register.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_register", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_unregister.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_unregister", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).xthreadsafe.expect(stringify!( - "sqlite3_api contains null pointer for ", - "xthreadsafe", - " function" - )))() -} - -pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_zeroblob", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_code.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_code", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_test_control( - arg1: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).test_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "test_control", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).randomness.expect(stringify!( - "sqlite3_api contains null pointer for ", - "randomness", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).context_db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "context_db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_extended_result_codes( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).extended_result_codes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "extended_result_codes", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_limit( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "limit", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).next_stmt.expect(stringify!( - "sqlite3_api contains null pointer for ", - "next_stmt", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sql.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sql", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_status( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "status", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_finish.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_finish", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_init( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut sqlite3, - arg4: *const ::std::os::raw::c_char, -) -> *mut sqlite3_backup { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_init.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_init", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_pagecount.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_pagecount", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_remaining.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_remaining", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_step( - arg1: *mut sqlite3_backup, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_step.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_step", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_compileoption_get( - arg1: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).compileoption_get.expect(stringify!( - "sqlite3_api contains null pointer for ", - "compileoption_get", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_compileoption_used( - arg1: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).compileoption_used.expect(stringify!( - "sqlite3_api contains null pointer for ", - "compileoption_used", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_function_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal, xDestroy) -} - -pub unsafe fn sqlite3_db_config( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, - vararg2: &mut i32, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_config.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_config", - " function" - )))(arg1, arg2, vararg1, vararg2) -} - -pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_mutex.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_mutex", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_db_status( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_status", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).extended_errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "extended_errcode", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_log( - arg1: ::std::os::raw::c_int, - arg2: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).log.expect(stringify!( - "sqlite3_api contains null pointer for ", - "log", - " function" - )))(arg1, arg2, vararg1) -} - -pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).soft_heap_limit64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "soft_heap_limit64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sourceid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sourceid", - " function" - )))() -} - -pub unsafe fn sqlite3_stmt_status( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_status", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_strnicmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).strnicmp.expect(stringify!( - "sqlite3_api contains null pointer for ", - "strnicmp", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_unlock_notify( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int), - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).unlock_notify.expect(stringify!( - "sqlite3_api contains null pointer for ", - "unlock_notify", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_wal_autocheckpoint( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_autocheckpoint", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_wal_checkpoint( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_checkpoint.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_checkpoint", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_wal_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_blob_reopen( - arg1: *mut sqlite3_blob, - arg2: sqlite3_int64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_reopen.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_reopen", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vtab_config( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vtab_config.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vtab_config", - " function" - )))(arg1, op, vararg1) -} - -pub unsafe fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vtab_on_conflict.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vtab_on_conflict", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "close_v2", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_db_filename( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_filename.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_filename", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_db_readonly( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_readonly.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_readonly", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_release_memory.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_release_memory", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errstr.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errstr", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_busy.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_busy", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_stmt_readonly(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_readonly.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_readonly", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_stricmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stricmp.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stricmp", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_uri_boolean( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).uri_boolean.expect(stringify!( - "sqlite3_api contains null pointer for ", - "uri_boolean", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_uri_int64( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_int64, -) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).uri_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "uri_int64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_uri_parameter( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).uri_parameter.expect(stringify!( - "sqlite3_api contains null pointer for ", - "uri_parameter", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vsnprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut __va_list_tag, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vsnprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vsnprintf", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_wal_checkpoint_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_checkpoint_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_checkpoint_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_auto_extension( - arg1: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).auto_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "auto_extension", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_blob64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_blob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_blob64", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_bind_text64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - arg6: ::std::os::raw::c_uchar, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text64", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_cancel_auto_extension( - arg1: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).cancel_auto_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "cancel_auto_extension", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_load_extension( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).load_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "load_extension", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_malloc64(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).malloc64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "malloc64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_msize(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).msize.expect(stringify!( - "sqlite3_api contains null pointer for ", - "msize", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_realloc64( - arg1: *mut ::std::os::raw::c_void, - arg2: sqlite3_uint64, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).realloc64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "realloc64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_reset_auto_extension() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).reset_auto_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "reset_auto_extension", - " function" - )))() -} - -pub unsafe fn sqlite3_result_blob64( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_blob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_blob64", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text64( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - arg5: ::std::os::raw::c_uchar, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text64", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_strglob( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).strglob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "strglob", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_value_dup(arg1: *const sqlite3_value) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_dup.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_dup", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_free(arg1: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_zeroblob64( - arg1: *mut sqlite3_context, - arg2: sqlite3_uint64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_zeroblob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_zeroblob64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_zeroblob64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_uint64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_zeroblob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_zeroblob64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_value_subtype(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_subtype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_subtype", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_subtype(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_subtype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_subtype", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_status64( - arg1: ::std::os::raw::c_int, - arg2: *mut sqlite3_int64, - arg3: *mut sqlite3_int64, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).status64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "status64", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_strlike( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_uint, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).strlike.expect(stringify!( - "sqlite3_api contains null pointer for ", - "strlike", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_db_cacheflush(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_cacheflush.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_cacheflush", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_system_errno(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).system_errno.expect(stringify!( - "sqlite3_api contains null pointer for ", - "system_errno", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_trace_v2( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_uint, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_uint, - arg2: *mut ::std::os::raw::c_void, - arg3: *mut ::std::os::raw::c_void, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).trace_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "trace_v2", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_expanded_sql(arg1: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).expanded_sql.expect(stringify!( - "sqlite3_api contains null pointer for ", - "expanded_sql", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_set_last_insert_rowid(arg1: *mut sqlite3, arg2: sqlite3_int64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_last_insert_rowid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_last_insert_rowid", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_prepare_v3( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_uint, - arg5: *mut *mut sqlite3_stmt, - arg6: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare_v3.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare_v3", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_prepare16_v3( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_uint, - arg5: *mut *mut sqlite3_stmt, - arg6: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16_v3.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16_v3", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_bind_pointer( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: *const ::std::os::raw::c_char, - arg5: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_pointer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_pointer", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_result_pointer( - arg1: *mut sqlite3_context, - arg2: *mut ::std::os::raw::c_void, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_pointer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_pointer", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_value_pointer( - arg1: *mut sqlite3_value, - arg2: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_pointer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_pointer", - " function" - )))(arg1, arg2) -} diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.20.0-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.20.0-ext.rs deleted file mode 100644 index 1332e1e66..000000000 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.20.0-ext.rs +++ /dev/null @@ -1,10507 +0,0 @@ -/* automatically generated by rust-bindgen */ - -pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.20.0\0"; -pub const SQLITE_VERSION_NUMBER: i32 = 3020000; -pub const SQLITE_SOURCE_ID: &'static [u8; 85usize] = - b"2017-08-01 13:24:15 9501e22dfeebdcefa783575e47c60b514d7c2e0cad73b2a496c0bc4b680900a8\0"; -pub const SQLITE_OK: i32 = 0; -pub const SQLITE_ERROR: i32 = 1; -pub const SQLITE_INTERNAL: i32 = 2; -pub const SQLITE_PERM: i32 = 3; -pub const SQLITE_ABORT: i32 = 4; -pub const SQLITE_BUSY: i32 = 5; -pub const SQLITE_LOCKED: i32 = 6; -pub const SQLITE_NOMEM: i32 = 7; -pub const SQLITE_READONLY: i32 = 8; -pub const SQLITE_INTERRUPT: i32 = 9; -pub const SQLITE_IOERR: i32 = 10; -pub const SQLITE_CORRUPT: i32 = 11; -pub const SQLITE_NOTFOUND: i32 = 12; -pub const SQLITE_FULL: i32 = 13; -pub const SQLITE_CANTOPEN: i32 = 14; -pub const SQLITE_PROTOCOL: i32 = 15; -pub const SQLITE_EMPTY: i32 = 16; -pub const SQLITE_SCHEMA: i32 = 17; -pub const SQLITE_TOOBIG: i32 = 18; -pub const SQLITE_CONSTRAINT: i32 = 19; -pub const SQLITE_MISMATCH: i32 = 20; -pub const SQLITE_MISUSE: i32 = 21; -pub const SQLITE_NOLFS: i32 = 22; -pub const SQLITE_AUTH: i32 = 23; -pub const SQLITE_FORMAT: i32 = 24; -pub const SQLITE_RANGE: i32 = 25; -pub const SQLITE_NOTADB: i32 = 26; -pub const SQLITE_NOTICE: i32 = 27; -pub const SQLITE_WARNING: i32 = 28; -pub const SQLITE_ROW: i32 = 100; -pub const SQLITE_DONE: i32 = 101; -pub const SQLITE_IOERR_READ: i32 = 266; -pub const SQLITE_IOERR_SHORT_READ: i32 = 522; -pub const SQLITE_IOERR_WRITE: i32 = 778; -pub const SQLITE_IOERR_FSYNC: i32 = 1034; -pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; -pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; -pub const SQLITE_IOERR_FSTAT: i32 = 1802; -pub const SQLITE_IOERR_UNLOCK: i32 = 2058; -pub const SQLITE_IOERR_RDLOCK: i32 = 2314; -pub const SQLITE_IOERR_DELETE: i32 = 2570; -pub const SQLITE_IOERR_BLOCKED: i32 = 2826; -pub const SQLITE_IOERR_NOMEM: i32 = 3082; -pub const SQLITE_IOERR_ACCESS: i32 = 3338; -pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; -pub const SQLITE_IOERR_LOCK: i32 = 3850; -pub const SQLITE_IOERR_CLOSE: i32 = 4106; -pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; -pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; -pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; -pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; -pub const SQLITE_IOERR_SHMMAP: i32 = 5386; -pub const SQLITE_IOERR_SEEK: i32 = 5642; -pub const SQLITE_IOERR_DELETE_NOENT: i32 = 5898; -pub const SQLITE_IOERR_MMAP: i32 = 6154; -pub const SQLITE_IOERR_GETTEMPPATH: i32 = 6410; -pub const SQLITE_IOERR_CONVPATH: i32 = 6666; -pub const SQLITE_IOERR_VNODE: i32 = 6922; -pub const SQLITE_IOERR_AUTH: i32 = 7178; -pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; -pub const SQLITE_BUSY_RECOVERY: i32 = 261; -pub const SQLITE_BUSY_SNAPSHOT: i32 = 517; -pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; -pub const SQLITE_CANTOPEN_ISDIR: i32 = 526; -pub const SQLITE_CANTOPEN_FULLPATH: i32 = 782; -pub const SQLITE_CANTOPEN_CONVPATH: i32 = 1038; -pub const SQLITE_CORRUPT_VTAB: i32 = 267; -pub const SQLITE_READONLY_RECOVERY: i32 = 264; -pub const SQLITE_READONLY_CANTLOCK: i32 = 520; -pub const SQLITE_READONLY_ROLLBACK: i32 = 776; -pub const SQLITE_READONLY_DBMOVED: i32 = 1032; -pub const SQLITE_ABORT_ROLLBACK: i32 = 516; -pub const SQLITE_CONSTRAINT_CHECK: i32 = 275; -pub const SQLITE_CONSTRAINT_COMMITHOOK: i32 = 531; -pub const SQLITE_CONSTRAINT_FOREIGNKEY: i32 = 787; -pub const SQLITE_CONSTRAINT_FUNCTION: i32 = 1043; -pub const SQLITE_CONSTRAINT_NOTNULL: i32 = 1299; -pub const SQLITE_CONSTRAINT_PRIMARYKEY: i32 = 1555; -pub const SQLITE_CONSTRAINT_TRIGGER: i32 = 1811; -pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067; -pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323; -pub const SQLITE_CONSTRAINT_ROWID: i32 = 2579; -pub const SQLITE_NOTICE_RECOVER_WAL: i32 = 283; -pub const SQLITE_NOTICE_RECOVER_ROLLBACK: i32 = 539; -pub const SQLITE_WARNING_AUTOINDEX: i32 = 284; -pub const SQLITE_AUTH_USER: i32 = 279; -pub const SQLITE_OK_LOAD_PERMANENTLY: i32 = 256; -pub const SQLITE_OPEN_READONLY: i32 = 1; -pub const SQLITE_OPEN_READWRITE: i32 = 2; -pub const SQLITE_OPEN_CREATE: i32 = 4; -pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; -pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; -pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; -pub const SQLITE_OPEN_URI: i32 = 64; -pub const SQLITE_OPEN_MEMORY: i32 = 128; -pub const SQLITE_OPEN_MAIN_DB: i32 = 256; -pub const SQLITE_OPEN_TEMP_DB: i32 = 512; -pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; -pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; -pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; -pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; -pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; -pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; -pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; -pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; -pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; -pub const SQLITE_OPEN_WAL: i32 = 524288; -pub const SQLITE_IOCAP_ATOMIC: i32 = 1; -pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; -pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; -pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; -pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; -pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; -pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; -pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; -pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; -pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; -pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; -pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; -pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE: i32 = 4096; -pub const SQLITE_IOCAP_IMMUTABLE: i32 = 8192; -pub const SQLITE_LOCK_NONE: i32 = 0; -pub const SQLITE_LOCK_SHARED: i32 = 1; -pub const SQLITE_LOCK_RESERVED: i32 = 2; -pub const SQLITE_LOCK_PENDING: i32 = 3; -pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; -pub const SQLITE_SYNC_NORMAL: i32 = 2; -pub const SQLITE_SYNC_FULL: i32 = 3; -pub const SQLITE_SYNC_DATAONLY: i32 = 16; -pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; -pub const SQLITE_FCNTL_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_FCNTL_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_FCNTL_LAST_ERRNO: i32 = 4; -pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; -pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; -pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; -pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; -pub const SQLITE_FCNTL_WIN32_AV_RETRY: i32 = 9; -pub const SQLITE_FCNTL_PERSIST_WAL: i32 = 10; -pub const SQLITE_FCNTL_OVERWRITE: i32 = 11; -pub const SQLITE_FCNTL_VFSNAME: i32 = 12; -pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE: i32 = 13; -pub const SQLITE_FCNTL_PRAGMA: i32 = 14; -pub const SQLITE_FCNTL_BUSYHANDLER: i32 = 15; -pub const SQLITE_FCNTL_TEMPFILENAME: i32 = 16; -pub const SQLITE_FCNTL_MMAP_SIZE: i32 = 18; -pub const SQLITE_FCNTL_TRACE: i32 = 19; -pub const SQLITE_FCNTL_HAS_MOVED: i32 = 20; -pub const SQLITE_FCNTL_SYNC: i32 = 21; -pub const SQLITE_FCNTL_COMMIT_PHASETWO: i32 = 22; -pub const SQLITE_FCNTL_WIN32_SET_HANDLE: i32 = 23; -pub const SQLITE_FCNTL_WAL_BLOCK: i32 = 24; -pub const SQLITE_FCNTL_ZIPVFS: i32 = 25; -pub const SQLITE_FCNTL_RBU: i32 = 26; -pub const SQLITE_FCNTL_VFS_POINTER: i32 = 27; -pub const SQLITE_FCNTL_JOURNAL_POINTER: i32 = 28; -pub const SQLITE_FCNTL_WIN32_GET_HANDLE: i32 = 29; -pub const SQLITE_FCNTL_PDB: i32 = 30; -pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_LAST_ERRNO: i32 = 4; -pub const SQLITE_ACCESS_EXISTS: i32 = 0; -pub const SQLITE_ACCESS_READWRITE: i32 = 1; -pub const SQLITE_ACCESS_READ: i32 = 2; -pub const SQLITE_SHM_UNLOCK: i32 = 1; -pub const SQLITE_SHM_LOCK: i32 = 2; -pub const SQLITE_SHM_SHARED: i32 = 4; -pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; -pub const SQLITE_SHM_NLOCK: i32 = 8; -pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; -pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; -pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; -pub const SQLITE_CONFIG_MALLOC: i32 = 4; -pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; -pub const SQLITE_CONFIG_SCRATCH: i32 = 6; -pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; -pub const SQLITE_CONFIG_HEAP: i32 = 8; -pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; -pub const SQLITE_CONFIG_MUTEX: i32 = 10; -pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; -pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; -pub const SQLITE_CONFIG_PCACHE: i32 = 14; -pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; -pub const SQLITE_CONFIG_LOG: i32 = 16; -pub const SQLITE_CONFIG_URI: i32 = 17; -pub const SQLITE_CONFIG_PCACHE2: i32 = 18; -pub const SQLITE_CONFIG_GETPCACHE2: i32 = 19; -pub const SQLITE_CONFIG_COVERING_INDEX_SCAN: i32 = 20; -pub const SQLITE_CONFIG_SQLLOG: i32 = 21; -pub const SQLITE_CONFIG_MMAP_SIZE: i32 = 22; -pub const SQLITE_CONFIG_WIN32_HEAPSIZE: i32 = 23; -pub const SQLITE_CONFIG_PCACHE_HDRSZ: i32 = 24; -pub const SQLITE_CONFIG_PMASZ: i32 = 25; -pub const SQLITE_CONFIG_STMTJRNL_SPILL: i32 = 26; -pub const SQLITE_DBCONFIG_MAINDBNAME: i32 = 1000; -pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; -pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; -pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; -pub const SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: i32 = 1004; -pub const SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: i32 = 1005; -pub const SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE: i32 = 1006; -pub const SQLITE_DBCONFIG_ENABLE_QPSG: i32 = 1007; -pub const SQLITE_DENY: i32 = 1; -pub const SQLITE_IGNORE: i32 = 2; -pub const SQLITE_CREATE_INDEX: i32 = 1; -pub const SQLITE_CREATE_TABLE: i32 = 2; -pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; -pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; -pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; -pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; -pub const SQLITE_CREATE_TRIGGER: i32 = 7; -pub const SQLITE_CREATE_VIEW: i32 = 8; -pub const SQLITE_DELETE: i32 = 9; -pub const SQLITE_DROP_INDEX: i32 = 10; -pub const SQLITE_DROP_TABLE: i32 = 11; -pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; -pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; -pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; -pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; -pub const SQLITE_DROP_TRIGGER: i32 = 16; -pub const SQLITE_DROP_VIEW: i32 = 17; -pub const SQLITE_INSERT: i32 = 18; -pub const SQLITE_PRAGMA: i32 = 19; -pub const SQLITE_READ: i32 = 20; -pub const SQLITE_SELECT: i32 = 21; -pub const SQLITE_TRANSACTION: i32 = 22; -pub const SQLITE_UPDATE: i32 = 23; -pub const SQLITE_ATTACH: i32 = 24; -pub const SQLITE_DETACH: i32 = 25; -pub const SQLITE_ALTER_TABLE: i32 = 26; -pub const SQLITE_REINDEX: i32 = 27; -pub const SQLITE_ANALYZE: i32 = 28; -pub const SQLITE_CREATE_VTABLE: i32 = 29; -pub const SQLITE_DROP_VTABLE: i32 = 30; -pub const SQLITE_FUNCTION: i32 = 31; -pub const SQLITE_SAVEPOINT: i32 = 32; -pub const SQLITE_COPY: i32 = 0; -pub const SQLITE_RECURSIVE: i32 = 33; -pub const SQLITE_TRACE_STMT: i32 = 1; -pub const SQLITE_TRACE_PROFILE: i32 = 2; -pub const SQLITE_TRACE_ROW: i32 = 4; -pub const SQLITE_TRACE_CLOSE: i32 = 8; -pub const SQLITE_LIMIT_LENGTH: i32 = 0; -pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; -pub const SQLITE_LIMIT_COLUMN: i32 = 2; -pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; -pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; -pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; -pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; -pub const SQLITE_LIMIT_ATTACHED: i32 = 7; -pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; -pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; -pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; -pub const SQLITE_LIMIT_WORKER_THREADS: i32 = 11; -pub const SQLITE_PREPARE_PERSISTENT: i32 = 1; -pub const SQLITE_INTEGER: i32 = 1; -pub const SQLITE_FLOAT: i32 = 2; -pub const SQLITE_BLOB: i32 = 4; -pub const SQLITE_NULL: i32 = 5; -pub const SQLITE_TEXT: i32 = 3; -pub const SQLITE3_TEXT: i32 = 3; -pub const SQLITE_UTF8: i32 = 1; -pub const SQLITE_UTF16LE: i32 = 2; -pub const SQLITE_UTF16BE: i32 = 3; -pub const SQLITE_UTF16: i32 = 4; -pub const SQLITE_ANY: i32 = 5; -pub const SQLITE_UTF16_ALIGNED: i32 = 8; -pub const SQLITE_DETERMINISTIC: i32 = 2048; -pub const SQLITE_INDEX_SCAN_UNIQUE: i32 = 1; -pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; -pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; -pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; -pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; -pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; -pub const SQLITE_INDEX_CONSTRAINT_LIKE: i32 = 65; -pub const SQLITE_INDEX_CONSTRAINT_GLOB: i32 = 66; -pub const SQLITE_INDEX_CONSTRAINT_REGEXP: i32 = 67; -pub const SQLITE_MUTEX_FAST: i32 = 0; -pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; -pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; -pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; -pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; -pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; -pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; -pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; -pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; -pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; -pub const SQLITE_MUTEX_STATIC_APP1: i32 = 8; -pub const SQLITE_MUTEX_STATIC_APP2: i32 = 9; -pub const SQLITE_MUTEX_STATIC_APP3: i32 = 10; -pub const SQLITE_MUTEX_STATIC_VFS1: i32 = 11; -pub const SQLITE_MUTEX_STATIC_VFS2: i32 = 12; -pub const SQLITE_MUTEX_STATIC_VFS3: i32 = 13; -pub const SQLITE_TESTCTRL_FIRST: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; -pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; -pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; -pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; -pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; -pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; -pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; -pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; -pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; -pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; -pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; -pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 17; -pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 18; -pub const SQLITE_TESTCTRL_EXPLAIN_STMT: i32 = 19; -pub const SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD: i32 = 19; -pub const SQLITE_TESTCTRL_NEVER_CORRUPT: i32 = 20; -pub const SQLITE_TESTCTRL_VDBE_COVERAGE: i32 = 21; -pub const SQLITE_TESTCTRL_BYTEORDER: i32 = 22; -pub const SQLITE_TESTCTRL_ISINIT: i32 = 23; -pub const SQLITE_TESTCTRL_SORTER_MMAP: i32 = 24; -pub const SQLITE_TESTCTRL_IMPOSTER: i32 = 25; -pub const SQLITE_TESTCTRL_LAST: i32 = 25; -pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; -pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; -pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; -pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; -pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; -pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; -pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; -pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; -pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; -pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; -pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; -pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; -pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; -pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; -pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; -pub const SQLITE_DBSTATUS_CACHE_HIT: i32 = 7; -pub const SQLITE_DBSTATUS_CACHE_MISS: i32 = 8; -pub const SQLITE_DBSTATUS_CACHE_WRITE: i32 = 9; -pub const SQLITE_DBSTATUS_DEFERRED_FKS: i32 = 10; -pub const SQLITE_DBSTATUS_CACHE_USED_SHARED: i32 = 11; -pub const SQLITE_DBSTATUS_MAX: i32 = 11; -pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; -pub const SQLITE_STMTSTATUS_SORT: i32 = 2; -pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; -pub const SQLITE_STMTSTATUS_VM_STEP: i32 = 4; -pub const SQLITE_STMTSTATUS_REPREPARE: i32 = 5; -pub const SQLITE_STMTSTATUS_RUN: i32 = 6; -pub const SQLITE_STMTSTATUS_MEMUSED: i32 = 99; -pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; -pub const SQLITE_CHECKPOINT_FULL: i32 = 1; -pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; -pub const SQLITE_CHECKPOINT_TRUNCATE: i32 = 3; -pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; -pub const SQLITE_ROLLBACK: i32 = 1; -pub const SQLITE_FAIL: i32 = 3; -pub const SQLITE_REPLACE: i32 = 5; -pub const SQLITE_SCANSTAT_NLOOP: i32 = 0; -pub const SQLITE_SCANSTAT_NVISIT: i32 = 1; -pub const SQLITE_SCANSTAT_EST: i32 = 2; -pub const SQLITE_SCANSTAT_NAME: i32 = 3; -pub const SQLITE_SCANSTAT_EXPLAIN: i32 = 4; -pub const SQLITE_SCANSTAT_SELECTID: i32 = 5; -pub const NOT_WITHIN: i32 = 0; -pub const PARTLY_WITHIN: i32 = 1; -pub const FULLY_WITHIN: i32 = 2; -pub const FTS5_TOKENIZE_QUERY: i32 = 1; -pub const FTS5_TOKENIZE_PREFIX: i32 = 2; -pub const FTS5_TOKENIZE_DOCUMENT: i32 = 4; -pub const FTS5_TOKENIZE_AUX: i32 = 8; -pub const FTS5_TOKEN_COLOCATED: i32 = 1; -pub type va_list = __builtin_va_list; -pub type __gnuc_va_list = __builtin_va_list; -extern "C" { - #[link_name = "\u{1}sqlite3_version"] - pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3 { - _unused: [u8; 0], -} -pub type sqlite_int64 = ::std::os::raw::c_longlong; -pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; -pub type sqlite3_int64 = sqlite_int64; -pub type sqlite3_uint64 = sqlite_uint64; -pub type sqlite3_callback = ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_file { - pub pMethods: *const sqlite3_io_methods, -} -#[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_file)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_file)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_file), - "::", - stringify!(pMethods) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_io_methods { - pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xRead: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *mut ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xWrite: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *const ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pSize: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xUnlock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCheckReservedLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileControl: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - op: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xSectorSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xDeviceCharacteristics: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xShmMap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iPg: ::std::os::raw::c_int, - pgsz: ::std::os::raw::c_int, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xShmLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - offset: ::std::os::raw::c_int, - n: ::std::os::raw::c_int, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xShmBarrier: ::std::option::Option, - pub xShmUnmap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - deleteFlag: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iOfst: sqlite3_int64, - iAmt: ::std::os::raw::c_int, - pp: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xUnfetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iOfst: sqlite3_int64, - p: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_io_methods() { - assert_eq!( - ::std::mem::size_of::(), - 152usize, - concat!("Size of: ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xRead) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xWrite) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnlock) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xCheckReservedLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileControl) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSectorSize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ - as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xDeviceCharacteristics) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmMap) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmBarrier) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmUnmap) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnfetch as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnfetch) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex { - _unused: [u8; 0], -} -pub type sqlite3_syscall_ptr = ::std::option::Option; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vfs { - pub iVersion: ::std::os::raw::c_int, - pub szOsFile: ::std::os::raw::c_int, - pub mxPathname: ::std::os::raw::c_int, - pub pNext: *mut sqlite3_vfs, - pub zName: *const ::std::os::raw::c_char, - pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - pOutFlags: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - syncDir: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xAccess: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - flags: ::std::os::raw::c_int, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFullPathname: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - nOut: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xDlOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zFilename: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void, - >, - pub xDlError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zErrMsg: *mut ::std::os::raw::c_char, - ), - >, - pub xDlSym: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ) -> ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ), - >, - >, - pub xDlClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), - >, - pub xRandomness: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSleep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - microseconds: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTime: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, - >, - pub xGetLastError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTimeInt64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xSetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: sqlite3_syscall_ptr, - ) -> ::std::os::raw::c_int, - >, - pub xGetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> sqlite3_syscall_ptr, - >, - pub xNextSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!( - ::std::mem::size_of::(), - 168usize, - concat!("Size of: ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(szOsFile) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(mxPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(zName) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pAppData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xAccess) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xFullPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlSym) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xRandomness) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSleep) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTime) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetLastError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTimeInt64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xNextSystemCall) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xRoundup: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub pAppData: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!( - ::std::mem::size_of::(), - 64usize, - concat!("Size of: ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xMalloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xFree) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRealloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRoundup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(pAppData) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_value { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_context { - _unused: [u8; 0], -} -pub type sqlite3_destructor_type = - ::std::option::Option; -extern "C" { - #[link_name = "\u{1}sqlite3_temp_directory"] - pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; -} -extern "C" { - #[link_name = "\u{1}sqlite3_data_directory"] - pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xConnect: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xBestIndex: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: *mut sqlite3_index_info, - ) -> ::std::os::raw::c_int, - >, - pub xDisconnect: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xDestroy: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - ppCursor: *mut *mut sqlite3_vtab_cursor, - ) -> ::std::os::raw::c_int, - >, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xFilter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - idxNum: ::std::os::raw::c_int, - idxStr: *const ::std::os::raw::c_char, - argc: ::std::os::raw::c_int, - argv: *mut *mut sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub xNext: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xEof: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - arg2: *mut sqlite3_context, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - pRowid: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xUpdate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - arg4: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xBegin: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xCommit: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xRollback: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xFindFunction: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - nArg: ::std::os::raw::c_int, - zName: *const ::std::os::raw::c_char, - pxFunc: *mut ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - ppArg: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xRename: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - zNew: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSavepoint: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRelease: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRollbackTo: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!( - ::std::mem::size_of::(), - 184usize, - concat!("Size of: ", stringify!(sqlite3_module)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_module)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xConnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBestIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDisconnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFilter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xEof) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xColumn) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xUpdate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBegin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCommit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollback) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFindFunction) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRename) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSavepoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRelease) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollbackTo) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info { - pub nConstraint: ::std::os::raw::c_int, - pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, - pub nOrderBy: ::std::os::raw::c_int, - pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, - pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, - pub idxNum: ::std::os::raw::c_int, - pub idxStr: *mut ::std::os::raw::c_char, - pub needToFreeIdxStr: ::std::os::raw::c_int, - pub orderByConsumed: ::std::os::raw::c_int, - pub estimatedCost: f64, - pub estimatedRows: sqlite3_int64, - pub idxFlags: ::std::os::raw::c_int, - pub colUsed: sqlite3_uint64, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint { - pub iColumn: ::std::os::raw::c_int, - pub op: ::std::os::raw::c_uchar, - pub usable: ::std::os::raw::c_uchar, - pub iTermOffset: ::std::os::raw::c_int, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).op as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(op) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).usable - as *const _ as usize - }, - 5usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(usable) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iTermOffset - as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iTermOffset) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_orderby { - pub iColumn: ::std::os::raw::c_int, - pub desc: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).desc as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(desc) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint_usage { - pub argvIndex: ::std::os::raw::c_int, - pub omit: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).argvIndex - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(argvIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).omit - as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(omit) - ) - ); -} -#[test] -fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!( - ::std::mem::size_of::(), - 96usize, - concat!("Size of: ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nOrderBy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aOrderBy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraintUsage) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxNum) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(needToFreeIdxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(orderByConsumed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedCost as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedCost) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedRows as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedRows) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxFlags as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxFlags) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).colUsed as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(colUsed) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(pModule) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(nRef) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(zErrMsg) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab_cursor { - pub pVtab: *mut sqlite3_vtab, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab_cursor), - "::", - stringify!(pVtab) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexNotheld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexInit as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnd) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexAlloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexFree as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexFree) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexTry) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexLeave) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexHeld) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexNotheld) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_page { - pub pBuf: *mut ::std::os::raw::c_void, - pub pExtra: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_page() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(sqlite3_pcache_page)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_page)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_page), - "::", - stringify!(pBuf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_page), - "::", - stringify!(pExtra) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods2 { - pub iVersion: ::std::os::raw::c_int, - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - szExtra: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache_page, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut sqlite3_pcache_page, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut sqlite3_pcache_page, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, - pub xShrink: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods2() { - assert_eq!( - ::std::mem::size_of::(), - 104usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iVersion as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDestroy as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xShrink) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods { - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!( - ::std::mem::size_of::(), - 88usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xDestroy) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_backup { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct sqlite3_snapshot { - pub hidden: [::std::os::raw::c_uchar; 48usize], -} -#[test] -fn bindgen_test_layout_sqlite3_snapshot() { - assert_eq!( - ::std::mem::size_of::(), - 48usize, - concat!("Size of: ", stringify!(sqlite3_snapshot)) - ); - assert_eq!( - ::std::mem::align_of::(), - 1usize, - concat!("Alignment of ", stringify!(sqlite3_snapshot)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).hidden as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_snapshot), - "::", - stringify!(hidden) - ) - ); -} -pub type sqlite3_rtree_dbl = f64; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_rtree_geometry { - pub pContext: *mut ::std::os::raw::c_void, - pub nParam: ::std::os::raw::c_int, - pub aParam: *mut sqlite3_rtree_dbl, - pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_rtree_geometry() { - assert_eq!( - ::std::mem::size_of::(), - 40usize, - concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pContext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(nParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(aParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pUser) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(xDelUser) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_rtree_query_info { - pub pContext: *mut ::std::os::raw::c_void, - pub nParam: ::std::os::raw::c_int, - pub aParam: *mut sqlite3_rtree_dbl, - pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, - pub aCoord: *mut sqlite3_rtree_dbl, - pub anQueue: *mut ::std::os::raw::c_uint, - pub nCoord: ::std::os::raw::c_int, - pub iLevel: ::std::os::raw::c_int, - pub mxLevel: ::std::os::raw::c_int, - pub iRowid: sqlite3_int64, - pub rParentScore: sqlite3_rtree_dbl, - pub eParentWithin: ::std::os::raw::c_int, - pub eWithin: ::std::os::raw::c_int, - pub rScore: sqlite3_rtree_dbl, - pub apSqlParam: *mut *mut sqlite3_value, -} -#[test] -fn bindgen_test_layout_sqlite3_rtree_query_info() { - assert_eq!( - ::std::mem::size_of::(), - 112usize, - concat!("Size of: ", stringify!(sqlite3_rtree_query_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_rtree_query_info)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).pContext as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(pContext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(nParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(aParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(pUser) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDelUser as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(xDelUser) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aCoord as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(aCoord) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).anQueue as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(anQueue) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nCoord as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(nCoord) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iLevel as *const _ as usize }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(iLevel) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mxLevel as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(mxLevel) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iRowid as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(iRowid) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rParentScore as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(rParentScore) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).eParentWithin as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(eParentWithin) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).eWithin as *const _ as usize - }, - 92usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(eWithin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).rScore as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(rScore) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).apSqlParam as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(apSqlParam) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5Context { - _unused: [u8; 0], -} -pub type fts5_extension_function = ::std::option::Option< - unsafe extern "C" fn( - pApi: *const Fts5ExtensionApi, - pFts: *mut Fts5Context, - pCtx: *mut sqlite3_context, - nVal: ::std::os::raw::c_int, - apVal: *mut *mut sqlite3_value, - ), ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5PhraseIter { - pub a: *const ::std::os::raw::c_uchar, - pub b: *const ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_Fts5PhraseIter() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(Fts5PhraseIter)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Fts5PhraseIter)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).a as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Fts5PhraseIter), - "::", - stringify!(a) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).b as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Fts5PhraseIter), - "::", - stringify!(b) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5ExtensionApi { - pub iVersion: ::std::os::raw::c_int, - pub xUserData: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> *mut ::std::os::raw::c_void, - >, - pub xColumnCount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, - >, - pub xRowCount: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pnRow: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xColumnTotalSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pnToken: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTokenize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pText: *const ::std::os::raw::c_char, - nText: ::std::os::raw::c_int, - pCtx: *mut ::std::os::raw::c_void, - xToken: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, - arg6: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseCount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, - >, - pub xPhraseSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xInstCount: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pnInst: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xInst: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iIdx: ::std::os::raw::c_int, - piPhrase: *mut ::std::os::raw::c_int, - piCol: *mut ::std::os::raw::c_int, - piOff: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: - ::std::option::Option sqlite3_int64>, - pub xColumnText: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pz: *mut *const ::std::os::raw::c_char, - pn: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xColumnSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pnToken: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xQueryPhrase: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - pUserData: *mut ::std::os::raw::c_void, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const Fts5ExtensionApi, - arg2: *mut Fts5Context, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub xSetAuxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pAux: *mut ::std::os::raw::c_void, - xDelete: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub xGetAuxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - bClear: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xPhraseFirst: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - arg2: *mut Fts5PhraseIter, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseNext: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - arg2: *mut Fts5PhraseIter, - piCol: *mut ::std::os::raw::c_int, - piOff: *mut ::std::os::raw::c_int, - ), - >, - pub xPhraseFirstColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - arg2: *mut Fts5PhraseIter, - arg3: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseNextColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - arg2: *mut Fts5PhraseIter, - piCol: *mut ::std::os::raw::c_int, - ), - >, -} -#[test] -fn bindgen_test_layout_Fts5ExtensionApi() { - assert_eq!( - ::std::mem::size_of::(), - 160usize, - concat!("Size of: ", stringify!(Fts5ExtensionApi)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Fts5ExtensionApi)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUserData as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xUserData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnCount as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowCount as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xRowCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xColumnTotalSize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnTotalSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xTokenize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseCount as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseSize as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInstCount as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xInstCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInst as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xInst) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnText as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnText) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnSize as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xQueryPhrase as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xQueryPhrase) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSetAuxdata as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xSetAuxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetAuxdata as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xGetAuxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseFirst as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseFirst) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseNext as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseNext) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPhraseFirstColumn as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseFirstColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPhraseNextColumn as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseNextColumn) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5Tokenizer { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct fts5_tokenizer { - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - azArg: *mut *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ppOut: *mut *mut Fts5Tokenizer, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option, - pub xTokenize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Tokenizer, - pCtx: *mut ::std::os::raw::c_void, - flags: ::std::os::raw::c_int, - pText: *const ::std::os::raw::c_char, - nText: ::std::os::raw::c_int, - xToken: ::std::option::Option< - unsafe extern "C" fn( - pCtx: *mut ::std::os::raw::c_void, - tflags: ::std::os::raw::c_int, - pToken: *const ::std::os::raw::c_char, - nToken: ::std::os::raw::c_int, - iStart: ::std::os::raw::c_int, - iEnd: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_fts5_tokenizer() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(fts5_tokenizer)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(fts5_tokenizer)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xTokenize) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct fts5_api { - pub iVersion: ::std::os::raw::c_int, - pub xCreateTokenizer: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - pContext: *mut ::std::os::raw::c_void, - pTokenizer: *mut fts5_tokenizer, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub xFindTokenizer: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - ppContext: *mut *mut ::std::os::raw::c_void, - pTokenizer: *mut fts5_tokenizer, - ) -> ::std::os::raw::c_int, - >, - pub xCreateFunction: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - pContext: *mut ::std::os::raw::c_void, - xFunction: fts5_extension_function, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_fts5_api() { - assert_eq!( - ::std::mem::size_of::(), - 32usize, - concat!("Size of: ", stringify!(fts5_api)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(fts5_api)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreateTokenizer as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xCreateTokenizer) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindTokenizer as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xFindTokenizer) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreateFunction as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xCreateFunction) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_api_routines { - pub aggregate_context: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub aggregate_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, - >, - pub bind_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_double: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, - ) -> ::std::os::raw::c_int, - >, - pub bind_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_int64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, - ) -> ::std::os::raw::c_int, - >, - pub bind_null: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub bind_parameter_index: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub bind_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub busy_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub busy_timeout: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub changes: - ::std::option::Option ::std::os::raw::c_int>, - pub close: - ::std::option::Option ::std::os::raw::c_int>, - pub collation_needed: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub collation_needed16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub column_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_bytes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_bytes16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub column_database_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_database_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_decltype: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_decltype16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_double: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, - >, - pub column_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_int64: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, - >, - pub column_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_origin_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_origin_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_table_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_table_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_uchar, - >, - pub column_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_type: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *mut sqlite3_value, - >, - pub commit_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub complete: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, - pub complete16: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub create_collation: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_collation16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_function16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_module: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub data_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub db_handle: - ::std::option::Option *mut sqlite3>, - pub declare_vtab: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub enable_shared_cache: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub errcode: - ::std::option::Option ::std::os::raw::c_int>, - pub errmsg: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, - >, - pub errmsg16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, - >, - pub exec: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub expired: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub finalize: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub free: ::std::option::Option, - pub free_table: - ::std::option::Option, - pub get_autocommit: - ::std::option::Option ::std::os::raw::c_int>, - pub get_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub get_table: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub global_recover: ::std::option::Option ::std::os::raw::c_int>, - pub interruptx: ::std::option::Option, - pub last_insert_rowid: - ::std::option::Option sqlite_int64>, - pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, - pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, - pub malloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub mprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub open16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub prepare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub profile: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub progress_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, - ), - >, - pub realloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub reset: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub result_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_double: - ::std::option::Option, - pub result_error: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_error16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_int64: - ::std::option::Option, - pub result_null: ::std::option::Option, - pub result_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16be: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16le: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_value: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), - >, - pub rollback_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub set_authorizer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub set_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, - ), - >, - pub snprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub step: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub table_column_metadata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub thread_cleanup: ::std::option::Option, - pub total_changes: - ::std::option::Option ::std::os::raw::c_int>, - pub trace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub transfer_bindings: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, - ) -> ::std::os::raw::c_int, - >, - pub update_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub user_data: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, - >, - pub value_blob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_bytes16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_double: ::std::option::Option f64>, - pub value_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_int64: - ::std::option::Option sqlite_int64>, - pub value_numeric_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_text: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, - >, - pub value_text16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16be: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16le: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub vmprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char, - >, - pub overload_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub prepare_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub clear_bindings: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub create_module_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_zeroblob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_close: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, - ) -> ::std::os::raw::c_int, - >, - pub blob_read: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_write: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub create_collation_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub file_control: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub memory_highwater: - ::std::option::Option sqlite3_int64>, - pub memory_used: ::std::option::Option sqlite3_int64>, - pub mutex_alloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub mutex_enter: ::std::option::Option, - pub mutex_free: ::std::option::Option, - pub mutex_leave: ::std::option::Option, - pub mutex_try: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub open_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub release_memory: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub result_error_nomem: ::std::option::Option, - pub result_error_toobig: - ::std::option::Option, - pub sleep: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub soft_heap_limit: ::std::option::Option, - pub vfs_find: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, - >, - pub vfs_register: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub vfs_unregister: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, - >, - pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, - pub result_zeroblob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_error_code: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub test_control: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, - >, - pub randomness: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), - >, - pub context_db_handle: - ::std::option::Option *mut sqlite3>, - pub extended_result_codes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub limit: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub next_stmt: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, - >, - pub sql: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, - >, - pub status: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub backup_finish: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_init: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut sqlite3, - arg4: *const ::std::os::raw::c_char, - ) -> *mut sqlite3_backup, - >, - pub backup_pagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_remaining: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_step: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_backup, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub compileoption_get: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, - >, - pub compileoption_used: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, - pub create_function_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub db_config: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int, - >, - pub db_mutex: - ::std::option::Option *mut sqlite3_mutex>, - pub db_status: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub extended_errcode: - ::std::option::Option ::std::os::raw::c_int>, - pub log: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char, ...), - >, - pub soft_heap_limit64: - ::std::option::Option sqlite3_int64>, - pub sourceid: ::std::option::Option *const ::std::os::raw::c_char>, - pub stmt_status: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub strnicmp: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub unlock_notify: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub wal_autocheckpoint: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub wal_checkpoint: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub wal_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub blob_reopen: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob, arg2: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub vtab_config: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int, - >, - pub vtab_on_conflict: - ::std::option::Option ::std::os::raw::c_int>, - pub close_v2: - ::std::option::Option ::std::os::raw::c_int>, - pub db_filename: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, - pub db_readonly: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub db_release_memory: - ::std::option::Option ::std::os::raw::c_int>, - pub errstr: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, - >, - pub stmt_busy: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub stmt_readonly: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub stricmp: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub uri_boolean: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub uri_int64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_int64, - ) -> sqlite3_int64, - >, - pub uri_parameter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, - pub vsnprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char, - >, - pub wal_checkpoint_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub auto_extension: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_blob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_text64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - arg6: ::std::os::raw::c_uchar, - ) -> ::std::os::raw::c_int, - >, - pub cancel_auto_extension: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub load_extension: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub malloc64: ::std::option::Option< - unsafe extern "C" fn(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void, - >, - pub msize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64, - >, - pub realloc64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: sqlite3_uint64, - ) -> *mut ::std::os::raw::c_void, - >, - pub reset_auto_extension: ::std::option::Option, - pub result_blob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - ), - >, - pub result_text64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - arg5: ::std::os::raw::c_uchar, - ), - >, - pub strglob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub value_dup: ::std::option::Option< - unsafe extern "C" fn(arg1: *const sqlite3_value) -> *mut sqlite3_value, - >, - pub value_free: ::std::option::Option, - pub result_zeroblob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: sqlite3_uint64, - ) -> ::std::os::raw::c_int, - >, - pub bind_zeroblob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_uint64, - ) -> ::std::os::raw::c_int, - >, - pub value_subtype: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint, - >, - pub result_subtype: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint), - >, - pub status64: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut sqlite3_int64, - arg3: *mut sqlite3_int64, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub strlike: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_uint, - ) -> ::std::os::raw::c_int, - >, - pub db_cacheflush: - ::std::option::Option ::std::os::raw::c_int>, - pub system_errno: - ::std::option::Option ::std::os::raw::c_int>, - pub trace_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_uint, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_uint, - arg2: *mut ::std::os::raw::c_void, - arg3: *mut ::std::os::raw::c_void, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub expanded_sql: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char, - >, - pub set_last_insert_rowid: - ::std::option::Option, - pub prepare_v3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_uint, - arg5: *mut *mut sqlite3_stmt, - arg6: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16_v3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_uint, - arg5: *mut *mut sqlite3_stmt, - arg6: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub bind_pointer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: *const ::std::os::raw::c_char, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub result_pointer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *mut ::std::os::raw::c_void, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::option::Option, - ), - >, - pub value_pointer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_value, - arg2: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_api_routines() { - assert_eq!( - ::std::mem::size_of::(), - 1776usize, - concat!("Size of: ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_context as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_context) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_count as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_double as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_count as *const _ - as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_index as *const _ - as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_index) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_name as *const _ - as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_text16 as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_handler as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_handler) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_timeout as *const _ as usize - }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_timeout) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(close) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed as *const _ as usize - }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_blob as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes as *const _ as usize - }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize - }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_count as *const _ as usize - }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name as *const _ - as usize - }, - 184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name16 as *const _ - as usize - }, - 192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype as *const _ as usize - }, - 200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize - }, - 208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_double as *const _ as usize - }, - 216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, - 224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_int64 as *const _ as usize - }, - 232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name as *const _ as usize - }, - 240usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name16 as *const _ as usize - }, - 248usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name as *const _ as usize - }, - 256usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name16 as *const _ - as usize - }, - 264usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name as *const _ as usize - }, - 272usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name16 as *const _ - as usize - }, - 280usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text as *const _ as usize - }, - 288usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text16 as *const _ as usize - }, - 296usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_type as *const _ as usize - }, - 304usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_type) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_value as *const _ as usize - }, - 312usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).commit_hook as *const _ as usize - }, - 320usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(commit_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, - 328usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, - 336usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation as *const _ as usize - }, - 344usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation16 as *const _ as usize - }, - 352usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function as *const _ as usize - }, - 360usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function16 as *const _ as usize - }, - 368usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module as *const _ as usize - }, - 376usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, - 384usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(data_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, - 392usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).declare_vtab as *const _ as usize - }, - 400usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(declare_vtab) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).enable_shared_cache as *const _ - as usize - }, - 408usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(enable_shared_cache) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, - 416usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, - 424usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, - 432usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, - 440usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(exec) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, - 448usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(expired) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, - 456usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(finalize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, - 464usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, - 472usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_autocommit as *const _ as usize - }, - 480usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_autocommit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_auxdata as *const _ as usize - }, - 488usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, - 496usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).global_recover as *const _ as usize - }, - 504usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(global_recover) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, - 512usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(interruptx) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize - }, - 520usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(last_insert_rowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, - 528usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).libversion_number as *const _ as usize - }, - 536usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion_number) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, - 544usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(malloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, - 552usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, - 560usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, - 568usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, - 576usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, - 584usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, - 592usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(profile) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).progress_handler as *const _ as usize - }, - 600usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(progress_handler) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, - 608usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(realloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, - 616usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(reset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_blob as *const _ as usize - }, - 624usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_double as *const _ as usize - }, - 632usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_double) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error as *const _ as usize - }, - 640usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error16 as *const _ as usize - }, - 648usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, - 656usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_int64 as *const _ as usize - }, - 664usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_null as *const _ as usize - }, - 672usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text as *const _ as usize - }, - 680usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16 as *const _ as usize - }, - 688usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16be as *const _ as usize - }, - 696usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16le as *const _ as usize - }, - 704usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16le) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_value as *const _ as usize - }, - 712usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rollback_hook as *const _ as usize - }, - 720usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(rollback_hook) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_authorizer as *const _ as usize - }, - 728usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_authorizer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_auxdata as *const _ as usize - }, - 736usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).snprintf as *const _ as usize }, - 744usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(snprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, - 752usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(step) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).table_column_metadata as *const _ - as usize - }, - 760usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(table_column_metadata) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize - }, - 768usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(thread_cleanup) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).total_changes as *const _ as usize - }, - 776usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(total_changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, - 784usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(trace) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize - }, - 792usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(transfer_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).update_hook as *const _ as usize - }, - 800usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(update_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, - 808usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(user_data) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, - 816usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes as *const _ as usize - }, - 824usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize - }, - 832usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_double as *const _ as usize - }, - 840usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, - 848usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_int64 as *const _ as usize - }, - 856usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize - }, - 864usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_numeric_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, - 872usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16 as *const _ as usize - }, - 880usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16be as *const _ as usize - }, - 888usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16le as *const _ as usize - }, - 896usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16le) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, - 904usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, - 912usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vmprintf) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).overload_function as *const _ as usize - }, - 920usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(overload_function) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, - 928usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize - }, - 936usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).clear_bindings as *const _ as usize - }, - 944usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(clear_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize - }, - 952usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize - }, - 960usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_zeroblob) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, - 968usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_bytes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, - 976usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_close) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, - 984usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, - 992usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_read) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, - 1000usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_write) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation_v2 as *const _ - as usize - }, - 1008usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).file_control as *const _ as usize - }, - 1016usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(file_control) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_highwater as *const _ as usize - }, - 1024usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_highwater) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_used as *const _ as usize - }, - 1032usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_used) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize - }, - 1040usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_alloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_enter as *const _ as usize - }, - 1048usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_enter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, - 1056usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_free) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_leave as *const _ as usize - }, - 1064usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_leave) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, - 1072usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_try) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, - 1080usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).release_memory as *const _ as usize - }, - 1088usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(release_memory) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize - }, - 1096usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_nomem) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_toobig as *const _ - as usize - }, - 1104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_toobig) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, - 1112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sleep) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize - }, - 1120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(soft_heap_limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, - 1128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_find) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_register as *const _ as usize - }, - 1136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_register) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize - }, - 1144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_unregister) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize - }, - 1152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(xthreadsafe) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize - }, - 1160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_zeroblob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_code as *const _ as usize - }, - 1168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_code) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).test_control as *const _ as usize - }, - 1176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(test_control) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, - 1184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(randomness) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).context_db_handle as *const _ as usize - }, - 1192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(context_db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).extended_result_codes as *const _ - as usize - }, - 1200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(extended_result_codes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, - 1208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, - 1216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(next_stmt) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, - 1224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sql) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, - 1232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(status) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_finish as *const _ as usize - }, - 1240usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_finish) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_init as *const _ as usize - }, - 1248usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_init) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_pagecount as *const _ as usize - }, - 1256usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_pagecount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_remaining as *const _ as usize - }, - 1264usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_remaining) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_step as *const _ as usize - }, - 1272usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_step) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).compileoption_get as *const _ as usize - }, - 1280usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(compileoption_get) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).compileoption_used as *const _ as usize - }, - 1288usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(compileoption_used) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function_v2 as *const _ as usize - }, - 1296usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function_v2) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_config as *const _ as usize }, - 1304usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_config) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_mutex as *const _ as usize }, - 1312usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_mutex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_status as *const _ as usize }, - 1320usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_status) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).extended_errcode as *const _ as usize - }, - 1328usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(extended_errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).log as *const _ as usize }, - 1336usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(log) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).soft_heap_limit64 as *const _ as usize - }, - 1344usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(soft_heap_limit64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sourceid as *const _ as usize }, - 1352usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sourceid) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stmt_status as *const _ as usize - }, - 1360usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_status) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).strnicmp as *const _ as usize }, - 1368usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(strnicmp) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).unlock_notify as *const _ as usize - }, - 1376usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(unlock_notify) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_autocheckpoint as *const _ as usize - }, - 1384usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_autocheckpoint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_checkpoint as *const _ as usize - }, - 1392usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_checkpoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).wal_hook as *const _ as usize }, - 1400usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_hook) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).blob_reopen as *const _ as usize - }, - 1408usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_reopen) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtab_config as *const _ as usize - }, - 1416usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vtab_config) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtab_on_conflict as *const _ as usize - }, - 1424usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vtab_on_conflict) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).close_v2 as *const _ as usize }, - 1432usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(close_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_filename as *const _ as usize - }, - 1440usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_filename) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_readonly as *const _ as usize - }, - 1448usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_readonly) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_release_memory as *const _ as usize - }, - 1456usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_release_memory) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errstr as *const _ as usize }, - 1464usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errstr) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).stmt_busy as *const _ as usize }, - 1472usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_busy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stmt_readonly as *const _ as usize - }, - 1480usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_readonly) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).stricmp as *const _ as usize }, - 1488usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stricmp) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).uri_boolean as *const _ as usize - }, - 1496usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(uri_boolean) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).uri_int64 as *const _ as usize }, - 1504usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(uri_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).uri_parameter as *const _ as usize - }, - 1512usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(uri_parameter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vsnprintf as *const _ as usize }, - 1520usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vsnprintf) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_checkpoint_v2 as *const _ as usize - }, - 1528usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_checkpoint_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).auto_extension as *const _ as usize - }, - 1536usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(auto_extension) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_blob64 as *const _ as usize - }, - 1544usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_blob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_text64 as *const _ as usize - }, - 1552usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).cancel_auto_extension as *const _ - as usize - }, - 1560usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(cancel_auto_extension) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).load_extension as *const _ as usize - }, - 1568usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(load_extension) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).malloc64 as *const _ as usize }, - 1576usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(malloc64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).msize as *const _ as usize }, - 1584usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(msize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).realloc64 as *const _ as usize }, - 1592usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(realloc64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).reset_auto_extension as *const _ - as usize - }, - 1600usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(reset_auto_extension) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_blob64 as *const _ as usize - }, - 1608usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_blob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text64 as *const _ as usize - }, - 1616usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).strglob as *const _ as usize }, - 1624usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(strglob) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_dup as *const _ as usize }, - 1632usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_dup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_free as *const _ as usize }, - 1640usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_free) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_zeroblob64 as *const _ as usize - }, - 1648usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_zeroblob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_zeroblob64 as *const _ as usize - }, - 1656usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_zeroblob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_subtype as *const _ as usize - }, - 1664usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_subtype) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_subtype as *const _ as usize - }, - 1672usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_subtype) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).status64 as *const _ as usize }, - 1680usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(status64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).strlike as *const _ as usize }, - 1688usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(strlike) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_cacheflush as *const _ as usize - }, - 1696usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_cacheflush) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).system_errno as *const _ as usize - }, - 1704usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(system_errno) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).trace_v2 as *const _ as usize }, - 1712usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(trace_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).expanded_sql as *const _ as usize - }, - 1720usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(expanded_sql) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_last_insert_rowid as *const _ - as usize - }, - 1728usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_last_insert_rowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare_v3 as *const _ as usize }, - 1736usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare_v3) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).prepare16_v3 as *const _ as usize - }, - 1744usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16_v3) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_pointer as *const _ as usize - }, - 1752usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_pointer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_pointer as *const _ as usize - }, - 1760usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_pointer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_pointer as *const _ as usize - }, - 1768usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_pointer) - ) - ); -} -pub type sqlite3_loadext_entry = ::std::option::Option< - unsafe extern "C" fn( - db: *mut sqlite3, - pzErrMsg: *mut *mut ::std::os::raw::c_char, - pThunk: *const sqlite3_api_routines, - ) -> ::std::os::raw::c_int, ->; -pub type __builtin_va_list = [__va_list_tag; 1usize]; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct __va_list_tag { - pub gp_offset: ::std::os::raw::c_uint, - pub fp_offset: ::std::os::raw::c_uint, - pub overflow_arg_area: *mut ::std::os::raw::c_void, - pub reg_save_area: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout___va_list_tag() { - assert_eq!( - ::std::mem::size_of::<__va_list_tag>(), - 24usize, - concat!("Size of: ", stringify!(__va_list_tag)) - ); - assert_eq!( - ::std::mem::align_of::<__va_list_tag>(), - 8usize, - concat!("Alignment of ", stringify!(__va_list_tag)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(gp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(fp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(overflow_arg_area) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(reg_save_area) - ) - ); -} - -// bindings were built with (non-embedded) loadable_extension: -// we define our own sqlite_api static variable and export it -// to C -#[no_mangle] -pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_routines; - -// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) - -pub unsafe fn sqlite3_aggregate_context( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_context.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_context", - " function" - )))(arg1, nBytes) -} - -pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_blob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_blob", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_double( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_double", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_null( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_null", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_parameter_index( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_index.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_index", - " function" - )))(arg1, zName) -} - -pub unsafe fn sqlite3_bind_parameter_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_text( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_text16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_bind_value( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_value", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_handler( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_handler", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_timeout( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_timeout.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_timeout", - " function" - )))(arg1, ms) -} - -pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_collation_needed( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_collation_needed16( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_column_blob( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_blob", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_column_database_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_database_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_decltype( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype", - " function" - )))(arg1, i) -} - -pub unsafe fn sqlite3_column_decltype16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_double", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int64( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int64", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_text( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_text16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_type( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_type", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_value( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_value", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_commit_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).commit_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "commit_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete16", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_create_collation( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_collation16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_function( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_function16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function16", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_module( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).data_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "data_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_declare_vtab( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).declare_vtab.expect(stringify!( - "sqlite3_api contains null pointer for ", - "declare_vtab", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).enable_shared_cache.expect(stringify!( - "sqlite3_api contains null pointer for ", - "enable_shared_cache", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errcode", - " function" - )))(db) -} - -pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_exec( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).exec.expect(stringify!( - "sqlite3_api contains null pointer for ", - "exec", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).expired.expect(stringify!( - "sqlite3_api contains null pointer for ", - "expired", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).finalize.expect(stringify!( - "sqlite3_api contains null pointer for ", - "finalize", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free_table", - " function" - )))(result) -} - -pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_autocommit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_autocommit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_get_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_auxdata", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_get_table( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_table", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).global_recover.expect(stringify!( - "sqlite3_api contains null pointer for ", - "global_recover", - " function" - )))() -} - -pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).interruptx.expect(stringify!( - "sqlite3_api contains null pointer for ", - "interruptx", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).last_insert_rowid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "last_insert_rowid", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion", - " function" - )))() -} - -pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion_number.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion_number", - " function" - )))() -} - -pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).malloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "malloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mprintf( - arg1: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mprintf", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_open( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_open16( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_prepare( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_profile( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).profile.expect(stringify!( - "sqlite3_api contains null pointer for ", - "profile", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_progress_handler( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).progress_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "progress_handler", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_realloc( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).realloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "realloc", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).reset.expect(stringify!( - "sqlite3_api contains null pointer for ", - "reset", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_result_blob( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_blob", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_double", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_error16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_null", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_text( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16be( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16be", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16le( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16le", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_value", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_rollback_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).rollback_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "rollback_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_authorizer( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_authorizer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_authorizer", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_auxdata", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_snprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).snprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "snprintf", - " function" - )))(arg1, arg2, arg3, vararg1) -} - -pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).step.expect(stringify!( - "sqlite3_api contains null pointer for ", - "step", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_table_column_metadata( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).table_column_metadata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "table_column_metadata", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) -} - -pub unsafe fn sqlite3_thread_cleanup() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).thread_cleanup.expect(stringify!( - "sqlite3_api contains null pointer for ", - "thread_cleanup", - " function" - )))() -} - -pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).total_changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "total_changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_trace( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).trace.expect(stringify!( - "sqlite3_api contains null pointer for ", - "trace", - " function" - )))(arg1, xTrace, arg2) -} - -pub unsafe fn sqlite3_transfer_bindings( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).transfer_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "transfer_bindings", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_update_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).update_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "update_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).user_data.expect(stringify!( - "sqlite3_api contains null pointer for ", - "user_data", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_blob", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_double", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_numeric_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_numeric_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16be", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16le", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vmprintf( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vmprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vmprintf", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_overload_function( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).overload_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "overload_function", - " function" - )))(arg1, zFuncName, nArg) -} - -pub unsafe fn sqlite3_prepare_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).clear_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "clear_bindings", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_module_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module_v2", - " function" - )))(arg1, arg2, arg3, arg4, xDestroy) -} - -pub unsafe fn sqlite3_bind_zeroblob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_zeroblob", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_open( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_open", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) -} - -pub unsafe fn sqlite3_blob_read( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_read.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_read", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_blob_write( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_write.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_write", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_create_collation_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_file_control( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).file_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "file_control", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_highwater.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_highwater", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_used.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_used", - " function" - )))() -} - -pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_alloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_alloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_enter.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_enter", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_leave.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_leave", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_try.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_try", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_open_v2( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open_v2", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).release_memory.expect(stringify!( - "sqlite3_api contains null pointer for ", - "release_memory", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_nomem.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_nomem", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_toobig.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_toobig", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sleep.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sleep", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).soft_heap_limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "soft_heap_limit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_find.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_find", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_register( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_register.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_register", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_unregister.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_unregister", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).xthreadsafe.expect(stringify!( - "sqlite3_api contains null pointer for ", - "xthreadsafe", - " function" - )))() -} - -pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_zeroblob", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_code.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_code", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_test_control( - arg1: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).test_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "test_control", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).randomness.expect(stringify!( - "sqlite3_api contains null pointer for ", - "randomness", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).context_db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "context_db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_extended_result_codes( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).extended_result_codes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "extended_result_codes", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_limit( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "limit", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).next_stmt.expect(stringify!( - "sqlite3_api contains null pointer for ", - "next_stmt", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sql.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sql", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_status( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "status", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_finish.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_finish", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_init( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut sqlite3, - arg4: *const ::std::os::raw::c_char, -) -> *mut sqlite3_backup { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_init.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_init", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_pagecount.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_pagecount", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_remaining.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_remaining", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_step( - arg1: *mut sqlite3_backup, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_step.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_step", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_compileoption_get( - arg1: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).compileoption_get.expect(stringify!( - "sqlite3_api contains null pointer for ", - "compileoption_get", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_compileoption_used( - arg1: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).compileoption_used.expect(stringify!( - "sqlite3_api contains null pointer for ", - "compileoption_used", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_function_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal, xDestroy) -} - -pub unsafe fn sqlite3_db_config( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, - vararg2: &mut i32, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_config.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_config", - " function" - )))(arg1, arg2, vararg1, vararg2) -} - -pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_mutex.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_mutex", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_db_status( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_status", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).extended_errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "extended_errcode", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_log( - arg1: ::std::os::raw::c_int, - arg2: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).log.expect(stringify!( - "sqlite3_api contains null pointer for ", - "log", - " function" - )))(arg1, arg2, vararg1) -} - -pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).soft_heap_limit64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "soft_heap_limit64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sourceid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sourceid", - " function" - )))() -} - -pub unsafe fn sqlite3_stmt_status( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_status", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_strnicmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).strnicmp.expect(stringify!( - "sqlite3_api contains null pointer for ", - "strnicmp", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_unlock_notify( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int), - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).unlock_notify.expect(stringify!( - "sqlite3_api contains null pointer for ", - "unlock_notify", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_wal_autocheckpoint( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_autocheckpoint", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_wal_checkpoint( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_checkpoint.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_checkpoint", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_wal_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_blob_reopen( - arg1: *mut sqlite3_blob, - arg2: sqlite3_int64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_reopen.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_reopen", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vtab_config( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vtab_config.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vtab_config", - " function" - )))(arg1, op, vararg1) -} - -pub unsafe fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vtab_on_conflict.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vtab_on_conflict", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "close_v2", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_db_filename( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_filename.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_filename", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_db_readonly( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_readonly.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_readonly", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_release_memory.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_release_memory", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errstr.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errstr", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_busy.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_busy", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_stmt_readonly(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_readonly.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_readonly", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_stricmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stricmp.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stricmp", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_uri_boolean( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).uri_boolean.expect(stringify!( - "sqlite3_api contains null pointer for ", - "uri_boolean", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_uri_int64( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_int64, -) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).uri_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "uri_int64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_uri_parameter( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).uri_parameter.expect(stringify!( - "sqlite3_api contains null pointer for ", - "uri_parameter", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vsnprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut __va_list_tag, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vsnprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vsnprintf", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_wal_checkpoint_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_checkpoint_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_checkpoint_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_auto_extension( - arg1: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).auto_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "auto_extension", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_blob64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_blob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_blob64", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_bind_text64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - arg6: ::std::os::raw::c_uchar, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text64", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_cancel_auto_extension( - arg1: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).cancel_auto_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "cancel_auto_extension", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_load_extension( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).load_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "load_extension", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_malloc64(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).malloc64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "malloc64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_msize(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).msize.expect(stringify!( - "sqlite3_api contains null pointer for ", - "msize", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_realloc64( - arg1: *mut ::std::os::raw::c_void, - arg2: sqlite3_uint64, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).realloc64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "realloc64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_reset_auto_extension() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).reset_auto_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "reset_auto_extension", - " function" - )))() -} - -pub unsafe fn sqlite3_result_blob64( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_blob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_blob64", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text64( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - arg5: ::std::os::raw::c_uchar, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text64", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_strglob( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).strglob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "strglob", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_value_dup(arg1: *const sqlite3_value) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_dup.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_dup", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_free(arg1: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_zeroblob64( - arg1: *mut sqlite3_context, - arg2: sqlite3_uint64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_zeroblob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_zeroblob64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_zeroblob64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_uint64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_zeroblob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_zeroblob64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_value_subtype(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_subtype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_subtype", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_subtype(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_subtype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_subtype", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_status64( - arg1: ::std::os::raw::c_int, - arg2: *mut sqlite3_int64, - arg3: *mut sqlite3_int64, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).status64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "status64", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_strlike( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_uint, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).strlike.expect(stringify!( - "sqlite3_api contains null pointer for ", - "strlike", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_db_cacheflush(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_cacheflush.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_cacheflush", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_system_errno(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).system_errno.expect(stringify!( - "sqlite3_api contains null pointer for ", - "system_errno", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_trace_v2( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_uint, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_uint, - arg2: *mut ::std::os::raw::c_void, - arg3: *mut ::std::os::raw::c_void, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).trace_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "trace_v2", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_expanded_sql(arg1: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).expanded_sql.expect(stringify!( - "sqlite3_api contains null pointer for ", - "expanded_sql", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_set_last_insert_rowid(arg1: *mut sqlite3, arg2: sqlite3_int64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_last_insert_rowid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_last_insert_rowid", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_prepare_v3( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_uint, - arg5: *mut *mut sqlite3_stmt, - arg6: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare_v3.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare_v3", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_prepare16_v3( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_uint, - arg5: *mut *mut sqlite3_stmt, - arg6: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16_v3.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16_v3", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_bind_pointer( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: *const ::std::os::raw::c_char, - arg5: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_pointer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_pointer", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_result_pointer( - arg1: *mut sqlite3_context, - arg2: *mut ::std::os::raw::c_void, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_pointer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_pointer", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_value_pointer( - arg1: *mut sqlite3_value, - arg2: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_pointer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_pointer", - " function" - )))(arg1, arg2) -} diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.20.0.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.20.0.rs deleted file mode 100644 index 835532f5f..000000000 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.20.0.rs +++ /dev/null @@ -1,5030 +0,0 @@ -/* automatically generated by rust-bindgen */ - -pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.20.0\0"; -pub const SQLITE_VERSION_NUMBER: i32 = 3020000; -pub const SQLITE_SOURCE_ID: &'static [u8; 85usize] = - b"2017-08-01 13:24:15 9501e22dfeebdcefa783575e47c60b514d7c2e0cad73b2a496c0bc4b680900a8\0"; -pub const SQLITE_OK: i32 = 0; -pub const SQLITE_ERROR: i32 = 1; -pub const SQLITE_INTERNAL: i32 = 2; -pub const SQLITE_PERM: i32 = 3; -pub const SQLITE_ABORT: i32 = 4; -pub const SQLITE_BUSY: i32 = 5; -pub const SQLITE_LOCKED: i32 = 6; -pub const SQLITE_NOMEM: i32 = 7; -pub const SQLITE_READONLY: i32 = 8; -pub const SQLITE_INTERRUPT: i32 = 9; -pub const SQLITE_IOERR: i32 = 10; -pub const SQLITE_CORRUPT: i32 = 11; -pub const SQLITE_NOTFOUND: i32 = 12; -pub const SQLITE_FULL: i32 = 13; -pub const SQLITE_CANTOPEN: i32 = 14; -pub const SQLITE_PROTOCOL: i32 = 15; -pub const SQLITE_EMPTY: i32 = 16; -pub const SQLITE_SCHEMA: i32 = 17; -pub const SQLITE_TOOBIG: i32 = 18; -pub const SQLITE_CONSTRAINT: i32 = 19; -pub const SQLITE_MISMATCH: i32 = 20; -pub const SQLITE_MISUSE: i32 = 21; -pub const SQLITE_NOLFS: i32 = 22; -pub const SQLITE_AUTH: i32 = 23; -pub const SQLITE_FORMAT: i32 = 24; -pub const SQLITE_RANGE: i32 = 25; -pub const SQLITE_NOTADB: i32 = 26; -pub const SQLITE_NOTICE: i32 = 27; -pub const SQLITE_WARNING: i32 = 28; -pub const SQLITE_ROW: i32 = 100; -pub const SQLITE_DONE: i32 = 101; -pub const SQLITE_IOERR_READ: i32 = 266; -pub const SQLITE_IOERR_SHORT_READ: i32 = 522; -pub const SQLITE_IOERR_WRITE: i32 = 778; -pub const SQLITE_IOERR_FSYNC: i32 = 1034; -pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; -pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; -pub const SQLITE_IOERR_FSTAT: i32 = 1802; -pub const SQLITE_IOERR_UNLOCK: i32 = 2058; -pub const SQLITE_IOERR_RDLOCK: i32 = 2314; -pub const SQLITE_IOERR_DELETE: i32 = 2570; -pub const SQLITE_IOERR_BLOCKED: i32 = 2826; -pub const SQLITE_IOERR_NOMEM: i32 = 3082; -pub const SQLITE_IOERR_ACCESS: i32 = 3338; -pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; -pub const SQLITE_IOERR_LOCK: i32 = 3850; -pub const SQLITE_IOERR_CLOSE: i32 = 4106; -pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; -pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; -pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; -pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; -pub const SQLITE_IOERR_SHMMAP: i32 = 5386; -pub const SQLITE_IOERR_SEEK: i32 = 5642; -pub const SQLITE_IOERR_DELETE_NOENT: i32 = 5898; -pub const SQLITE_IOERR_MMAP: i32 = 6154; -pub const SQLITE_IOERR_GETTEMPPATH: i32 = 6410; -pub const SQLITE_IOERR_CONVPATH: i32 = 6666; -pub const SQLITE_IOERR_VNODE: i32 = 6922; -pub const SQLITE_IOERR_AUTH: i32 = 7178; -pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; -pub const SQLITE_BUSY_RECOVERY: i32 = 261; -pub const SQLITE_BUSY_SNAPSHOT: i32 = 517; -pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; -pub const SQLITE_CANTOPEN_ISDIR: i32 = 526; -pub const SQLITE_CANTOPEN_FULLPATH: i32 = 782; -pub const SQLITE_CANTOPEN_CONVPATH: i32 = 1038; -pub const SQLITE_CORRUPT_VTAB: i32 = 267; -pub const SQLITE_READONLY_RECOVERY: i32 = 264; -pub const SQLITE_READONLY_CANTLOCK: i32 = 520; -pub const SQLITE_READONLY_ROLLBACK: i32 = 776; -pub const SQLITE_READONLY_DBMOVED: i32 = 1032; -pub const SQLITE_ABORT_ROLLBACK: i32 = 516; -pub const SQLITE_CONSTRAINT_CHECK: i32 = 275; -pub const SQLITE_CONSTRAINT_COMMITHOOK: i32 = 531; -pub const SQLITE_CONSTRAINT_FOREIGNKEY: i32 = 787; -pub const SQLITE_CONSTRAINT_FUNCTION: i32 = 1043; -pub const SQLITE_CONSTRAINT_NOTNULL: i32 = 1299; -pub const SQLITE_CONSTRAINT_PRIMARYKEY: i32 = 1555; -pub const SQLITE_CONSTRAINT_TRIGGER: i32 = 1811; -pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067; -pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323; -pub const SQLITE_CONSTRAINT_ROWID: i32 = 2579; -pub const SQLITE_NOTICE_RECOVER_WAL: i32 = 283; -pub const SQLITE_NOTICE_RECOVER_ROLLBACK: i32 = 539; -pub const SQLITE_WARNING_AUTOINDEX: i32 = 284; -pub const SQLITE_AUTH_USER: i32 = 279; -pub const SQLITE_OK_LOAD_PERMANENTLY: i32 = 256; -pub const SQLITE_OPEN_READONLY: i32 = 1; -pub const SQLITE_OPEN_READWRITE: i32 = 2; -pub const SQLITE_OPEN_CREATE: i32 = 4; -pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; -pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; -pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; -pub const SQLITE_OPEN_URI: i32 = 64; -pub const SQLITE_OPEN_MEMORY: i32 = 128; -pub const SQLITE_OPEN_MAIN_DB: i32 = 256; -pub const SQLITE_OPEN_TEMP_DB: i32 = 512; -pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; -pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; -pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; -pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; -pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; -pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; -pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; -pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; -pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; -pub const SQLITE_OPEN_WAL: i32 = 524288; -pub const SQLITE_IOCAP_ATOMIC: i32 = 1; -pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; -pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; -pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; -pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; -pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; -pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; -pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; -pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; -pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; -pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; -pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; -pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE: i32 = 4096; -pub const SQLITE_IOCAP_IMMUTABLE: i32 = 8192; -pub const SQLITE_LOCK_NONE: i32 = 0; -pub const SQLITE_LOCK_SHARED: i32 = 1; -pub const SQLITE_LOCK_RESERVED: i32 = 2; -pub const SQLITE_LOCK_PENDING: i32 = 3; -pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; -pub const SQLITE_SYNC_NORMAL: i32 = 2; -pub const SQLITE_SYNC_FULL: i32 = 3; -pub const SQLITE_SYNC_DATAONLY: i32 = 16; -pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; -pub const SQLITE_FCNTL_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_FCNTL_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_FCNTL_LAST_ERRNO: i32 = 4; -pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; -pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; -pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; -pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; -pub const SQLITE_FCNTL_WIN32_AV_RETRY: i32 = 9; -pub const SQLITE_FCNTL_PERSIST_WAL: i32 = 10; -pub const SQLITE_FCNTL_OVERWRITE: i32 = 11; -pub const SQLITE_FCNTL_VFSNAME: i32 = 12; -pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE: i32 = 13; -pub const SQLITE_FCNTL_PRAGMA: i32 = 14; -pub const SQLITE_FCNTL_BUSYHANDLER: i32 = 15; -pub const SQLITE_FCNTL_TEMPFILENAME: i32 = 16; -pub const SQLITE_FCNTL_MMAP_SIZE: i32 = 18; -pub const SQLITE_FCNTL_TRACE: i32 = 19; -pub const SQLITE_FCNTL_HAS_MOVED: i32 = 20; -pub const SQLITE_FCNTL_SYNC: i32 = 21; -pub const SQLITE_FCNTL_COMMIT_PHASETWO: i32 = 22; -pub const SQLITE_FCNTL_WIN32_SET_HANDLE: i32 = 23; -pub const SQLITE_FCNTL_WAL_BLOCK: i32 = 24; -pub const SQLITE_FCNTL_ZIPVFS: i32 = 25; -pub const SQLITE_FCNTL_RBU: i32 = 26; -pub const SQLITE_FCNTL_VFS_POINTER: i32 = 27; -pub const SQLITE_FCNTL_JOURNAL_POINTER: i32 = 28; -pub const SQLITE_FCNTL_WIN32_GET_HANDLE: i32 = 29; -pub const SQLITE_FCNTL_PDB: i32 = 30; -pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_LAST_ERRNO: i32 = 4; -pub const SQLITE_ACCESS_EXISTS: i32 = 0; -pub const SQLITE_ACCESS_READWRITE: i32 = 1; -pub const SQLITE_ACCESS_READ: i32 = 2; -pub const SQLITE_SHM_UNLOCK: i32 = 1; -pub const SQLITE_SHM_LOCK: i32 = 2; -pub const SQLITE_SHM_SHARED: i32 = 4; -pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; -pub const SQLITE_SHM_NLOCK: i32 = 8; -pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; -pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; -pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; -pub const SQLITE_CONFIG_MALLOC: i32 = 4; -pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; -pub const SQLITE_CONFIG_SCRATCH: i32 = 6; -pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; -pub const SQLITE_CONFIG_HEAP: i32 = 8; -pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; -pub const SQLITE_CONFIG_MUTEX: i32 = 10; -pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; -pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; -pub const SQLITE_CONFIG_PCACHE: i32 = 14; -pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; -pub const SQLITE_CONFIG_LOG: i32 = 16; -pub const SQLITE_CONFIG_URI: i32 = 17; -pub const SQLITE_CONFIG_PCACHE2: i32 = 18; -pub const SQLITE_CONFIG_GETPCACHE2: i32 = 19; -pub const SQLITE_CONFIG_COVERING_INDEX_SCAN: i32 = 20; -pub const SQLITE_CONFIG_SQLLOG: i32 = 21; -pub const SQLITE_CONFIG_MMAP_SIZE: i32 = 22; -pub const SQLITE_CONFIG_WIN32_HEAPSIZE: i32 = 23; -pub const SQLITE_CONFIG_PCACHE_HDRSZ: i32 = 24; -pub const SQLITE_CONFIG_PMASZ: i32 = 25; -pub const SQLITE_CONFIG_STMTJRNL_SPILL: i32 = 26; -pub const SQLITE_DBCONFIG_MAINDBNAME: i32 = 1000; -pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; -pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; -pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; -pub const SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: i32 = 1004; -pub const SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: i32 = 1005; -pub const SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE: i32 = 1006; -pub const SQLITE_DBCONFIG_ENABLE_QPSG: i32 = 1007; -pub const SQLITE_DENY: i32 = 1; -pub const SQLITE_IGNORE: i32 = 2; -pub const SQLITE_CREATE_INDEX: i32 = 1; -pub const SQLITE_CREATE_TABLE: i32 = 2; -pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; -pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; -pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; -pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; -pub const SQLITE_CREATE_TRIGGER: i32 = 7; -pub const SQLITE_CREATE_VIEW: i32 = 8; -pub const SQLITE_DELETE: i32 = 9; -pub const SQLITE_DROP_INDEX: i32 = 10; -pub const SQLITE_DROP_TABLE: i32 = 11; -pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; -pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; -pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; -pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; -pub const SQLITE_DROP_TRIGGER: i32 = 16; -pub const SQLITE_DROP_VIEW: i32 = 17; -pub const SQLITE_INSERT: i32 = 18; -pub const SQLITE_PRAGMA: i32 = 19; -pub const SQLITE_READ: i32 = 20; -pub const SQLITE_SELECT: i32 = 21; -pub const SQLITE_TRANSACTION: i32 = 22; -pub const SQLITE_UPDATE: i32 = 23; -pub const SQLITE_ATTACH: i32 = 24; -pub const SQLITE_DETACH: i32 = 25; -pub const SQLITE_ALTER_TABLE: i32 = 26; -pub const SQLITE_REINDEX: i32 = 27; -pub const SQLITE_ANALYZE: i32 = 28; -pub const SQLITE_CREATE_VTABLE: i32 = 29; -pub const SQLITE_DROP_VTABLE: i32 = 30; -pub const SQLITE_FUNCTION: i32 = 31; -pub const SQLITE_SAVEPOINT: i32 = 32; -pub const SQLITE_COPY: i32 = 0; -pub const SQLITE_RECURSIVE: i32 = 33; -pub const SQLITE_TRACE_STMT: i32 = 1; -pub const SQLITE_TRACE_PROFILE: i32 = 2; -pub const SQLITE_TRACE_ROW: i32 = 4; -pub const SQLITE_TRACE_CLOSE: i32 = 8; -pub const SQLITE_LIMIT_LENGTH: i32 = 0; -pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; -pub const SQLITE_LIMIT_COLUMN: i32 = 2; -pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; -pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; -pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; -pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; -pub const SQLITE_LIMIT_ATTACHED: i32 = 7; -pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; -pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; -pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; -pub const SQLITE_LIMIT_WORKER_THREADS: i32 = 11; -pub const SQLITE_PREPARE_PERSISTENT: i32 = 1; -pub const SQLITE_INTEGER: i32 = 1; -pub const SQLITE_FLOAT: i32 = 2; -pub const SQLITE_BLOB: i32 = 4; -pub const SQLITE_NULL: i32 = 5; -pub const SQLITE_TEXT: i32 = 3; -pub const SQLITE3_TEXT: i32 = 3; -pub const SQLITE_UTF8: i32 = 1; -pub const SQLITE_UTF16LE: i32 = 2; -pub const SQLITE_UTF16BE: i32 = 3; -pub const SQLITE_UTF16: i32 = 4; -pub const SQLITE_ANY: i32 = 5; -pub const SQLITE_UTF16_ALIGNED: i32 = 8; -pub const SQLITE_DETERMINISTIC: i32 = 2048; -pub const SQLITE_INDEX_SCAN_UNIQUE: i32 = 1; -pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; -pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; -pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; -pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; -pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; -pub const SQLITE_INDEX_CONSTRAINT_LIKE: i32 = 65; -pub const SQLITE_INDEX_CONSTRAINT_GLOB: i32 = 66; -pub const SQLITE_INDEX_CONSTRAINT_REGEXP: i32 = 67; -pub const SQLITE_MUTEX_FAST: i32 = 0; -pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; -pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; -pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; -pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; -pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; -pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; -pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; -pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; -pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; -pub const SQLITE_MUTEX_STATIC_APP1: i32 = 8; -pub const SQLITE_MUTEX_STATIC_APP2: i32 = 9; -pub const SQLITE_MUTEX_STATIC_APP3: i32 = 10; -pub const SQLITE_MUTEX_STATIC_VFS1: i32 = 11; -pub const SQLITE_MUTEX_STATIC_VFS2: i32 = 12; -pub const SQLITE_MUTEX_STATIC_VFS3: i32 = 13; -pub const SQLITE_TESTCTRL_FIRST: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; -pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; -pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; -pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; -pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; -pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; -pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; -pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; -pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; -pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; -pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; -pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 17; -pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 18; -pub const SQLITE_TESTCTRL_EXPLAIN_STMT: i32 = 19; -pub const SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD: i32 = 19; -pub const SQLITE_TESTCTRL_NEVER_CORRUPT: i32 = 20; -pub const SQLITE_TESTCTRL_VDBE_COVERAGE: i32 = 21; -pub const SQLITE_TESTCTRL_BYTEORDER: i32 = 22; -pub const SQLITE_TESTCTRL_ISINIT: i32 = 23; -pub const SQLITE_TESTCTRL_SORTER_MMAP: i32 = 24; -pub const SQLITE_TESTCTRL_IMPOSTER: i32 = 25; -pub const SQLITE_TESTCTRL_LAST: i32 = 25; -pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; -pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; -pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; -pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; -pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; -pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; -pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; -pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; -pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; -pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; -pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; -pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; -pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; -pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; -pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; -pub const SQLITE_DBSTATUS_CACHE_HIT: i32 = 7; -pub const SQLITE_DBSTATUS_CACHE_MISS: i32 = 8; -pub const SQLITE_DBSTATUS_CACHE_WRITE: i32 = 9; -pub const SQLITE_DBSTATUS_DEFERRED_FKS: i32 = 10; -pub const SQLITE_DBSTATUS_CACHE_USED_SHARED: i32 = 11; -pub const SQLITE_DBSTATUS_MAX: i32 = 11; -pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; -pub const SQLITE_STMTSTATUS_SORT: i32 = 2; -pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; -pub const SQLITE_STMTSTATUS_VM_STEP: i32 = 4; -pub const SQLITE_STMTSTATUS_REPREPARE: i32 = 5; -pub const SQLITE_STMTSTATUS_RUN: i32 = 6; -pub const SQLITE_STMTSTATUS_MEMUSED: i32 = 99; -pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; -pub const SQLITE_CHECKPOINT_FULL: i32 = 1; -pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; -pub const SQLITE_CHECKPOINT_TRUNCATE: i32 = 3; -pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; -pub const SQLITE_ROLLBACK: i32 = 1; -pub const SQLITE_FAIL: i32 = 3; -pub const SQLITE_REPLACE: i32 = 5; -pub const SQLITE_SCANSTAT_NLOOP: i32 = 0; -pub const SQLITE_SCANSTAT_NVISIT: i32 = 1; -pub const SQLITE_SCANSTAT_EST: i32 = 2; -pub const SQLITE_SCANSTAT_NAME: i32 = 3; -pub const SQLITE_SCANSTAT_EXPLAIN: i32 = 4; -pub const SQLITE_SCANSTAT_SELECTID: i32 = 5; -pub const NOT_WITHIN: i32 = 0; -pub const PARTLY_WITHIN: i32 = 1; -pub const FULLY_WITHIN: i32 = 2; -pub const FTS5_TOKENIZE_QUERY: i32 = 1; -pub const FTS5_TOKENIZE_PREFIX: i32 = 2; -pub const FTS5_TOKENIZE_DOCUMENT: i32 = 4; -pub const FTS5_TOKENIZE_AUX: i32 = 8; -pub const FTS5_TOKEN_COLOCATED: i32 = 1; -pub type va_list = __builtin_va_list; -pub type __gnuc_va_list = __builtin_va_list; -extern "C" { - #[link_name = "\u{1}sqlite3_version"] - pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; -} -extern "C" { - pub fn sqlite3_libversion() -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_sourceid() -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_libversion_number() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_compileoption_used( - zOptName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_compileoption_get(N: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_threadsafe() -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3 { - _unused: [u8; 0], -} -pub type sqlite_int64 = ::std::os::raw::c_longlong; -pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; -pub type sqlite3_int64 = sqlite_int64; -pub type sqlite3_uint64 = sqlite_uint64; -extern "C" { - pub fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -pub type sqlite3_callback = ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, ->; -extern "C" { - pub fn sqlite3_exec( - arg1: *mut sqlite3, - sql: *const ::std::os::raw::c_char, - callback: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg2: *mut ::std::os::raw::c_void, - errmsg: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_file { - pub pMethods: *const sqlite3_io_methods, -} -#[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_file)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_file)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_file), - "::", - stringify!(pMethods) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_io_methods { - pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xRead: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *mut ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xWrite: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *const ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pSize: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xUnlock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCheckReservedLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileControl: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - op: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xSectorSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xDeviceCharacteristics: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xShmMap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iPg: ::std::os::raw::c_int, - pgsz: ::std::os::raw::c_int, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xShmLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - offset: ::std::os::raw::c_int, - n: ::std::os::raw::c_int, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xShmBarrier: ::std::option::Option, - pub xShmUnmap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - deleteFlag: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iOfst: sqlite3_int64, - iAmt: ::std::os::raw::c_int, - pp: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xUnfetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iOfst: sqlite3_int64, - p: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_io_methods() { - assert_eq!( - ::std::mem::size_of::(), - 152usize, - concat!("Size of: ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xRead) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xWrite) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnlock) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xCheckReservedLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileControl) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSectorSize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ - as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xDeviceCharacteristics) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmMap) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmBarrier) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmUnmap) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnfetch as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnfetch) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_api_routines { - _unused: [u8; 0], -} -pub type sqlite3_syscall_ptr = ::std::option::Option; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vfs { - pub iVersion: ::std::os::raw::c_int, - pub szOsFile: ::std::os::raw::c_int, - pub mxPathname: ::std::os::raw::c_int, - pub pNext: *mut sqlite3_vfs, - pub zName: *const ::std::os::raw::c_char, - pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - pOutFlags: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - syncDir: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xAccess: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - flags: ::std::os::raw::c_int, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFullPathname: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - nOut: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xDlOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zFilename: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void, - >, - pub xDlError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zErrMsg: *mut ::std::os::raw::c_char, - ), - >, - pub xDlSym: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ) -> ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ), - >, - >, - pub xDlClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), - >, - pub xRandomness: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSleep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - microseconds: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTime: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, - >, - pub xGetLastError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTimeInt64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xSetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: sqlite3_syscall_ptr, - ) -> ::std::os::raw::c_int, - >, - pub xGetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> sqlite3_syscall_ptr, - >, - pub xNextSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!( - ::std::mem::size_of::(), - 168usize, - concat!("Size of: ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(szOsFile) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(mxPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(zName) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pAppData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xAccess) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xFullPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlSym) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xRandomness) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSleep) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTime) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetLastError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTimeInt64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xNextSystemCall) - ) - ); -} -extern "C" { - pub fn sqlite3_initialize() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_shutdown() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_os_init() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_os_end() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_db_config( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xRoundup: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub pAppData: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!( - ::std::mem::size_of::(), - 64usize, - concat!("Size of: ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xMalloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xFree) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRealloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRoundup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(pAppData) - ) - ); -} -extern "C" { - pub fn sqlite3_extended_result_codes( - arg1: *mut sqlite3, - onoff: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_set_last_insert_rowid(arg1: *mut sqlite3, arg2: sqlite3_int64); -} -extern "C" { - pub fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_interrupt(arg1: *mut sqlite3); -} -extern "C" { - pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_busy_handler( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_busy_timeout( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_get_table( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - pazResult: *mut *mut *mut ::std::os::raw::c_char, - pnRow: *mut ::std::os::raw::c_int, - pnColumn: *mut ::std::os::raw::c_int, - pzErrmsg: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char); -} -extern "C" { - pub fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char, ...) - -> *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_vmprintf( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_snprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_vsnprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_malloc64(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_realloc( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_realloc64( - arg1: *mut ::std::os::raw::c_void, - arg2: sqlite3_uint64, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_free(arg1: *mut ::std::os::raw::c_void); -} -extern "C" { - pub fn sqlite3_msize(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64; -} -extern "C" { - pub fn sqlite3_memory_used() -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_randomness(N: ::std::os::raw::c_int, P: *mut ::std::os::raw::c_void); -} -extern "C" { - pub fn sqlite3_set_authorizer( - arg1: *mut sqlite3, - xAuth: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pUserData: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_trace( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_profile( - arg1: *mut sqlite3, - xProfile: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_uint64, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_trace_v2( - arg1: *mut sqlite3, - uMask: ::std::os::raw::c_uint, - xCallback: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_uint, - arg2: *mut ::std::os::raw::c_void, - arg3: *mut ::std::os::raw::c_void, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pCtx: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_progress_handler( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, - ); -} -extern "C" { - pub fn sqlite3_open( - filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_open16( - filename: *const ::std::os::raw::c_void, - ppDb: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_open_v2( - filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3, - flags: ::std::os::raw::c_int, - zVfs: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_uri_parameter( - zFilename: *const ::std::os::raw::c_char, - zParam: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_uri_boolean( - zFile: *const ::std::os::raw::c_char, - zParam: *const ::std::os::raw::c_char, - bDefault: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_uri_int64( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_int64, - ) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_extended_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt { - _unused: [u8; 0], -} -extern "C" { - pub fn sqlite3_limit( - arg1: *mut sqlite3, - id: ::std::os::raw::c_int, - newVal: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_prepare( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_prepare_v2( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_prepare_v3( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - prepFlags: ::std::os::raw::c_uint, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_prepare16( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_prepare16_v2( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_prepare16_v3( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - prepFlags: ::std::os::raw::c_uint, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_expanded_sql(pStmt: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_stmt_readonly(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_value { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_context { - _unused: [u8; 0], -} -extern "C" { - pub fn sqlite3_bind_blob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_blob64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_double( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_int( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_int64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_int64, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_null( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_text( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_text16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_text64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - encoding: ::std::os::raw::c_uchar, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_value( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_pointer( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: *const ::std::os::raw::c_char, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_zeroblob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - n: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_zeroblob64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_uint64, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_bind_parameter_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_bind_parameter_index( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_name( - arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_column_name16( - arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_database_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_column_database_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_table_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_column_table_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_origin_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_column_origin_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_decltype( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_column_decltype16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_blob( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64; -} -extern "C" { - pub fn sqlite3_column_int( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_int64( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_column_text( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_uchar; -} -extern "C" { - pub fn sqlite3_column_text16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_column_value( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *mut sqlite3_value; -} -extern "C" { - pub fn sqlite3_column_bytes( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_bytes16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_column_type( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function( - db: *mut sqlite3, - zFunctionName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function16( - db: *mut sqlite3, - zFunctionName: *const ::std::os::raw::c_void, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function_v2( - db: *mut sqlite3, - zFunctionName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_transfer_bindings( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_global_recover() -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_thread_cleanup(); -} -extern "C" { - pub fn sqlite3_memory_alarm( - arg1: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: sqlite3_int64, - arg3: ::std::os::raw::c_int, - ), - >, - arg2: *mut ::std::os::raw::c_void, - arg3: sqlite3_int64, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64; -} -extern "C" { - pub fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_value_pointer( - arg1: *mut sqlite3_value, - arg2: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar; -} -extern "C" { - pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_value_subtype(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint; -} -extern "C" { - pub fn sqlite3_value_dup(arg1: *const sqlite3_value) -> *mut sqlite3_value; -} -extern "C" { - pub fn sqlite3_value_free(arg1: *mut sqlite3_value); -} -extern "C" { - pub fn sqlite3_aggregate_context( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3; -} -extern "C" { - pub fn sqlite3_get_auxdata( - arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_set_auxdata( - arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option, - ); -} -pub type sqlite3_destructor_type = - ::std::option::Option; -extern "C" { - pub fn sqlite3_result_blob( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_blob64( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64); -} -extern "C" { - pub fn sqlite3_result_error( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ); -} -extern "C" { - pub fn sqlite3_result_error16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - ); -} -extern "C" { - pub fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context); -} -extern "C" { - pub fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context); -} -extern "C" { - pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite3_int64); -} -extern "C" { - pub fn sqlite3_result_null(arg1: *mut sqlite3_context); -} -extern "C" { - pub fn sqlite3_result_text( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_text64( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - encoding: ::std::os::raw::c_uchar, - ); -} -extern "C" { - pub fn sqlite3_result_text16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_text16le( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_text16be( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value); -} -extern "C" { - pub fn sqlite3_result_pointer( - arg1: *mut sqlite3_context, - arg2: *mut ::std::os::raw::c_void, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, n: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_result_zeroblob64( - arg1: *mut sqlite3_context, - n: sqlite3_uint64, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_result_subtype(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint); -} -extern "C" { - pub fn sqlite3_create_collation( - arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - xCompare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation_v2( - arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - xCompare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation16( - arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_void, - eTextRep: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - xCompare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed16( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; -} -extern "C" { - #[link_name = "\u{1}sqlite3_temp_directory"] - pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; -} -extern "C" { - #[link_name = "\u{1}sqlite3_data_directory"] - pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3; -} -extern "C" { - pub fn sqlite3_db_filename( - db: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char; -} -extern "C" { - pub fn sqlite3_db_readonly( - db: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) -> *mut sqlite3_stmt; -} -extern "C" { - pub fn sqlite3_commit_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_rollback_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_update_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_soft_heap_limit64(N: sqlite3_int64) -> sqlite3_int64; -} -extern "C" { - pub fn sqlite3_soft_heap_limit(N: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_table_column_metadata( - db: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - zTableName: *const ::std::os::raw::c_char, - zColumnName: *const ::std::os::raw::c_char, - pzDataType: *mut *const ::std::os::raw::c_char, - pzCollSeq: *mut *const ::std::os::raw::c_char, - pNotNull: *mut ::std::os::raw::c_int, - pPrimaryKey: *mut ::std::os::raw::c_int, - pAutoinc: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_load_extension( - db: *mut sqlite3, - zFile: *const ::std::os::raw::c_char, - zProc: *const ::std::os::raw::c_char, - pzErrMsg: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_enable_load_extension( - db: *mut sqlite3, - onoff: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_auto_extension( - xEntryPoint: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_cancel_auto_extension( - xEntryPoint: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_reset_auto_extension(); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xConnect: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xBestIndex: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: *mut sqlite3_index_info, - ) -> ::std::os::raw::c_int, - >, - pub xDisconnect: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xDestroy: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - ppCursor: *mut *mut sqlite3_vtab_cursor, - ) -> ::std::os::raw::c_int, - >, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xFilter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - idxNum: ::std::os::raw::c_int, - idxStr: *const ::std::os::raw::c_char, - argc: ::std::os::raw::c_int, - argv: *mut *mut sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub xNext: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xEof: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - arg2: *mut sqlite3_context, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - pRowid: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xUpdate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - arg4: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xBegin: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xCommit: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xRollback: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xFindFunction: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - nArg: ::std::os::raw::c_int, - zName: *const ::std::os::raw::c_char, - pxFunc: *mut ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - ppArg: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xRename: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - zNew: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSavepoint: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRelease: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRollbackTo: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!( - ::std::mem::size_of::(), - 184usize, - concat!("Size of: ", stringify!(sqlite3_module)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_module)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xConnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBestIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDisconnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFilter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xEof) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xColumn) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xUpdate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBegin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCommit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollback) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFindFunction) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRename) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSavepoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRelease) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollbackTo) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info { - pub nConstraint: ::std::os::raw::c_int, - pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, - pub nOrderBy: ::std::os::raw::c_int, - pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, - pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, - pub idxNum: ::std::os::raw::c_int, - pub idxStr: *mut ::std::os::raw::c_char, - pub needToFreeIdxStr: ::std::os::raw::c_int, - pub orderByConsumed: ::std::os::raw::c_int, - pub estimatedCost: f64, - pub estimatedRows: sqlite3_int64, - pub idxFlags: ::std::os::raw::c_int, - pub colUsed: sqlite3_uint64, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint { - pub iColumn: ::std::os::raw::c_int, - pub op: ::std::os::raw::c_uchar, - pub usable: ::std::os::raw::c_uchar, - pub iTermOffset: ::std::os::raw::c_int, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).op as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(op) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).usable - as *const _ as usize - }, - 5usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(usable) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iTermOffset - as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iTermOffset) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_orderby { - pub iColumn: ::std::os::raw::c_int, - pub desc: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).desc as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(desc) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint_usage { - pub argvIndex: ::std::os::raw::c_int, - pub omit: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).argvIndex - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(argvIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).omit - as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(omit) - ) - ); -} -#[test] -fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!( - ::std::mem::size_of::(), - 96usize, - concat!("Size of: ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nOrderBy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aOrderBy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraintUsage) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxNum) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(needToFreeIdxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(orderByConsumed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedCost as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedCost) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedRows as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedRows) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxFlags as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxFlags) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).colUsed as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(colUsed) - ) - ); -} -extern "C" { - pub fn sqlite3_create_module( - db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - p: *const sqlite3_module, - pClientData: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_module_v2( - db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - p: *const sqlite3_module, - pClientData: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(pModule) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(nRef) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(zErrMsg) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab_cursor { - pub pVtab: *mut sqlite3_vtab, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab_cursor), - "::", - stringify!(pVtab) - ) - ); -} -extern "C" { - pub fn sqlite3_declare_vtab( - arg1: *mut sqlite3, - zSQL: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_overload_function( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob { - _unused: [u8; 0], -} -extern "C" { - pub fn sqlite3_blob_open( - arg1: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - zTable: *const ::std::os::raw::c_char, - zColumn: *const ::std::os::raw::c_char, - iRow: sqlite3_int64, - flags: ::std::os::raw::c_int, - ppBlob: *mut *mut sqlite3_blob, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_blob_reopen( - arg1: *mut sqlite3_blob, - arg2: sqlite3_int64, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_blob_read( - arg1: *mut sqlite3_blob, - Z: *mut ::std::os::raw::c_void, - N: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_blob_write( - arg1: *mut sqlite3_blob, - z: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs; -} -extern "C" { - pub fn sqlite3_vfs_register( - arg1: *mut sqlite3_vfs, - makeDflt: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex; -} -extern "C" { - pub fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex); -} -extern "C" { - pub fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex); -} -extern "C" { - pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexNotheld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexInit as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnd) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexAlloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexFree as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexFree) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexTry) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexLeave) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexHeld) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexNotheld) - ) - ); -} -extern "C" { - pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex; -} -extern "C" { - pub fn sqlite3_file_control( - arg1: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - op: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_status( - op: ::std::os::raw::c_int, - pCurrent: *mut ::std::os::raw::c_int, - pHighwater: *mut ::std::os::raw::c_int, - resetFlag: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_status64( - op: ::std::os::raw::c_int, - pCurrent: *mut sqlite3_int64, - pHighwater: *mut sqlite3_int64, - resetFlag: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_db_status( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - pCur: *mut ::std::os::raw::c_int, - pHiwtr: *mut ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_stmt_status( - arg1: *mut sqlite3_stmt, - op: ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_page { - pub pBuf: *mut ::std::os::raw::c_void, - pub pExtra: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_page() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(sqlite3_pcache_page)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_page)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_page), - "::", - stringify!(pBuf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_page), - "::", - stringify!(pExtra) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods2 { - pub iVersion: ::std::os::raw::c_int, - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - szExtra: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache_page, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut sqlite3_pcache_page, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut sqlite3_pcache_page, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, - pub xShrink: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods2() { - assert_eq!( - ::std::mem::size_of::(), - 104usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iVersion as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDestroy as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xShrink) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods { - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!( - ::std::mem::size_of::(), - 88usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xDestroy) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_backup { - _unused: [u8; 0], -} -extern "C" { - pub fn sqlite3_backup_init( - pDest: *mut sqlite3, - zDestName: *const ::std::os::raw::c_char, - pSource: *mut sqlite3, - zSourceName: *const ::std::os::raw::c_char, - ) -> *mut sqlite3_backup; -} -extern "C" { - pub fn sqlite3_backup_step( - p: *mut sqlite3_backup, - nPage: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_backup_finish(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_backup_remaining(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_backup_pagecount(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_unlock_notify( - pBlocked: *mut sqlite3, - xNotify: ::std::option::Option< - unsafe extern "C" fn( - apArg: *mut *mut ::std::os::raw::c_void, - nArg: ::std::os::raw::c_int, - ), - >, - pNotifyArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_stricmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_strnicmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_strglob( - zGlob: *const ::std::os::raw::c_char, - zStr: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_strlike( - zGlob: *const ::std::os::raw::c_char, - zStr: *const ::std::os::raw::c_char, - cEsc: ::std::os::raw::c_uint, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_log( - iErrCode: ::std::os::raw::c_int, - zFormat: *const ::std::os::raw::c_char, - ... - ); -} -extern "C" { - pub fn sqlite3_wal_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; -} -extern "C" { - pub fn sqlite3_wal_autocheckpoint( - db: *mut sqlite3, - N: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_wal_checkpoint( - db: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_wal_checkpoint_v2( - db: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - eMode: ::std::os::raw::c_int, - pnLog: *mut ::std::os::raw::c_int, - pnCkpt: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_vtab_config( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_stmt_scanstatus( - pStmt: *mut sqlite3_stmt, - idx: ::std::os::raw::c_int, - iScanStatusOp: ::std::os::raw::c_int, - pOut: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_stmt_scanstatus_reset(arg1: *mut sqlite3_stmt); -} -extern "C" { - pub fn sqlite3_db_cacheflush(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_system_errno(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct sqlite3_snapshot { - pub hidden: [::std::os::raw::c_uchar; 48usize], -} -#[test] -fn bindgen_test_layout_sqlite3_snapshot() { - assert_eq!( - ::std::mem::size_of::(), - 48usize, - concat!("Size of: ", stringify!(sqlite3_snapshot)) - ); - assert_eq!( - ::std::mem::align_of::(), - 1usize, - concat!("Alignment of ", stringify!(sqlite3_snapshot)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).hidden as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_snapshot), - "::", - stringify!(hidden) - ) - ); -} -extern "C" { - pub fn sqlite3_snapshot_get( - db: *mut sqlite3, - zSchema: *const ::std::os::raw::c_char, - ppSnapshot: *mut *mut sqlite3_snapshot, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_snapshot_open( - db: *mut sqlite3, - zSchema: *const ::std::os::raw::c_char, - pSnapshot: *mut sqlite3_snapshot, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_snapshot_free(arg1: *mut sqlite3_snapshot); -} -extern "C" { - pub fn sqlite3_snapshot_cmp( - p1: *mut sqlite3_snapshot, - p2: *mut sqlite3_snapshot, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_snapshot_recover( - db: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -pub type sqlite3_rtree_dbl = f64; -extern "C" { - pub fn sqlite3_rtree_geometry_callback( - db: *mut sqlite3, - zGeom: *const ::std::os::raw::c_char, - xGeom: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_rtree_geometry, - arg2: ::std::os::raw::c_int, - arg3: *mut sqlite3_rtree_dbl, - arg4: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pContext: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_rtree_geometry { - pub pContext: *mut ::std::os::raw::c_void, - pub nParam: ::std::os::raw::c_int, - pub aParam: *mut sqlite3_rtree_dbl, - pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_rtree_geometry() { - assert_eq!( - ::std::mem::size_of::(), - 40usize, - concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pContext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(nParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(aParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pUser) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(xDelUser) - ) - ); -} -extern "C" { - pub fn sqlite3_rtree_query_callback( - db: *mut sqlite3, - zQueryFunc: *const ::std::os::raw::c_char, - xQueryFunc: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_rtree_query_info) -> ::std::os::raw::c_int, - >, - pContext: *mut ::std::os::raw::c_void, - xDestructor: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_rtree_query_info { - pub pContext: *mut ::std::os::raw::c_void, - pub nParam: ::std::os::raw::c_int, - pub aParam: *mut sqlite3_rtree_dbl, - pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, - pub aCoord: *mut sqlite3_rtree_dbl, - pub anQueue: *mut ::std::os::raw::c_uint, - pub nCoord: ::std::os::raw::c_int, - pub iLevel: ::std::os::raw::c_int, - pub mxLevel: ::std::os::raw::c_int, - pub iRowid: sqlite3_int64, - pub rParentScore: sqlite3_rtree_dbl, - pub eParentWithin: ::std::os::raw::c_int, - pub eWithin: ::std::os::raw::c_int, - pub rScore: sqlite3_rtree_dbl, - pub apSqlParam: *mut *mut sqlite3_value, -} -#[test] -fn bindgen_test_layout_sqlite3_rtree_query_info() { - assert_eq!( - ::std::mem::size_of::(), - 112usize, - concat!("Size of: ", stringify!(sqlite3_rtree_query_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_rtree_query_info)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).pContext as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(pContext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(nParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(aParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(pUser) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDelUser as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(xDelUser) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aCoord as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(aCoord) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).anQueue as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(anQueue) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nCoord as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(nCoord) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iLevel as *const _ as usize }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(iLevel) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mxLevel as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(mxLevel) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iRowid as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(iRowid) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rParentScore as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(rParentScore) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).eParentWithin as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(eParentWithin) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).eWithin as *const _ as usize - }, - 92usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(eWithin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).rScore as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(rScore) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).apSqlParam as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(apSqlParam) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5Context { - _unused: [u8; 0], -} -pub type fts5_extension_function = ::std::option::Option< - unsafe extern "C" fn( - pApi: *const Fts5ExtensionApi, - pFts: *mut Fts5Context, - pCtx: *mut sqlite3_context, - nVal: ::std::os::raw::c_int, - apVal: *mut *mut sqlite3_value, - ), ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5PhraseIter { - pub a: *const ::std::os::raw::c_uchar, - pub b: *const ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_Fts5PhraseIter() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(Fts5PhraseIter)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Fts5PhraseIter)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).a as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Fts5PhraseIter), - "::", - stringify!(a) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).b as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Fts5PhraseIter), - "::", - stringify!(b) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5ExtensionApi { - pub iVersion: ::std::os::raw::c_int, - pub xUserData: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> *mut ::std::os::raw::c_void, - >, - pub xColumnCount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, - >, - pub xRowCount: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pnRow: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xColumnTotalSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pnToken: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTokenize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pText: *const ::std::os::raw::c_char, - nText: ::std::os::raw::c_int, - pCtx: *mut ::std::os::raw::c_void, - xToken: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, - arg6: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseCount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, - >, - pub xPhraseSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xInstCount: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pnInst: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xInst: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iIdx: ::std::os::raw::c_int, - piPhrase: *mut ::std::os::raw::c_int, - piCol: *mut ::std::os::raw::c_int, - piOff: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: - ::std::option::Option sqlite3_int64>, - pub xColumnText: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pz: *mut *const ::std::os::raw::c_char, - pn: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xColumnSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pnToken: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xQueryPhrase: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - pUserData: *mut ::std::os::raw::c_void, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const Fts5ExtensionApi, - arg2: *mut Fts5Context, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub xSetAuxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pAux: *mut ::std::os::raw::c_void, - xDelete: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub xGetAuxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - bClear: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xPhraseFirst: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - arg2: *mut Fts5PhraseIter, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseNext: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - arg2: *mut Fts5PhraseIter, - piCol: *mut ::std::os::raw::c_int, - piOff: *mut ::std::os::raw::c_int, - ), - >, - pub xPhraseFirstColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - arg2: *mut Fts5PhraseIter, - arg3: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseNextColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - arg2: *mut Fts5PhraseIter, - piCol: *mut ::std::os::raw::c_int, - ), - >, -} -#[test] -fn bindgen_test_layout_Fts5ExtensionApi() { - assert_eq!( - ::std::mem::size_of::(), - 160usize, - concat!("Size of: ", stringify!(Fts5ExtensionApi)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Fts5ExtensionApi)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUserData as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xUserData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnCount as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowCount as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xRowCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xColumnTotalSize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnTotalSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xTokenize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseCount as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseSize as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInstCount as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xInstCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInst as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xInst) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnText as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnText) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnSize as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xQueryPhrase as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xQueryPhrase) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSetAuxdata as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xSetAuxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetAuxdata as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xGetAuxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseFirst as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseFirst) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseNext as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseNext) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPhraseFirstColumn as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseFirstColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPhraseNextColumn as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseNextColumn) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5Tokenizer { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct fts5_tokenizer { - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - azArg: *mut *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ppOut: *mut *mut Fts5Tokenizer, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option, - pub xTokenize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Tokenizer, - pCtx: *mut ::std::os::raw::c_void, - flags: ::std::os::raw::c_int, - pText: *const ::std::os::raw::c_char, - nText: ::std::os::raw::c_int, - xToken: ::std::option::Option< - unsafe extern "C" fn( - pCtx: *mut ::std::os::raw::c_void, - tflags: ::std::os::raw::c_int, - pToken: *const ::std::os::raw::c_char, - nToken: ::std::os::raw::c_int, - iStart: ::std::os::raw::c_int, - iEnd: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_fts5_tokenizer() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(fts5_tokenizer)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(fts5_tokenizer)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xTokenize) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct fts5_api { - pub iVersion: ::std::os::raw::c_int, - pub xCreateTokenizer: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - pContext: *mut ::std::os::raw::c_void, - pTokenizer: *mut fts5_tokenizer, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub xFindTokenizer: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - ppContext: *mut *mut ::std::os::raw::c_void, - pTokenizer: *mut fts5_tokenizer, - ) -> ::std::os::raw::c_int, - >, - pub xCreateFunction: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - pContext: *mut ::std::os::raw::c_void, - xFunction: fts5_extension_function, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_fts5_api() { - assert_eq!( - ::std::mem::size_of::(), - 32usize, - concat!("Size of: ", stringify!(fts5_api)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(fts5_api)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreateTokenizer as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xCreateTokenizer) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindTokenizer as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xFindTokenizer) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreateFunction as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xCreateFunction) - ) - ); -} -pub type __builtin_va_list = [__va_list_tag; 1usize]; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct __va_list_tag { - pub gp_offset: ::std::os::raw::c_uint, - pub fp_offset: ::std::os::raw::c_uint, - pub overflow_arg_area: *mut ::std::os::raw::c_void, - pub reg_save_area: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout___va_list_tag() { - assert_eq!( - ::std::mem::size_of::<__va_list_tag>(), - 24usize, - concat!("Size of: ", stringify!(__va_list_tag)) - ); - assert_eq!( - ::std::mem::align_of::<__va_list_tag>(), - 8usize, - concat!("Alignment of ", stringify!(__va_list_tag)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(gp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(fp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(overflow_arg_area) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(reg_save_area) - ) - ); -} diff --git a/libsqlite3-sys/bindgen-bindings/generate-bindgen-bindings.sh b/libsqlite3-sys/bindgen-bindings/generate-bindgen-bindings.sh index 01ceb7bfa..1f4e7d469 100755 --- a/libsqlite3-sys/bindgen-bindings/generate-bindgen-bindings.sh +++ b/libsqlite3-sys/bindgen-bindings/generate-bindgen-bindings.sh @@ -69,6 +69,5 @@ function generate_bindgen_binding { cp "${bindgen_file}" "${output_path}" } -generate_bindgen_bindings 3.20.0 https://sqlite.org/2017/sqlite-amalgamation-3200000.zip sqlite-amalgamation-3200000/ generate_bindgen_bindings 3.7.16 https://sqlite.org/2013/sqlite-amalgamation-3071600.zip sqlite-amalgamation-3071600/ generate_bindgen_bindings 3.6.8 https://sqlite.org/sqlite-amalgamation-3_6_8.zip ./ diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index 70844d128..6d90429ae 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -406,8 +406,6 @@ mod bindings { "bindgen-bindings/bindgen_3.6.8", #[cfg(feature = "min_sqlite_version_3_7_16")] "bindgen-bindings/bindgen_3.7.16", - #[cfg(feature = "min_sqlite_version_3_20_0")] - "bindgen-bindings/bindgen_3.20.0", ]; pub fn write_to_out_dir(_header: HeaderLocation, out_path: &Path) { From d4b710a4f4b09699720109c1a34ebc4faf1893ea Mon Sep 17 00:00:00 2001 From: gwenn Date: Tue, 11 Feb 2020 20:32:39 +0100 Subject: [PATCH 08/61] Remove unused `vtab_v3` feature --- Cargo.toml | 2 -- 1 file changed, 2 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index a2c602a9b..0264ffd60 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -45,8 +45,6 @@ sqlcipher = ["libsqlite3-sys/sqlcipher"] unlock_notify = ["libsqlite3-sys/unlock_notify"] # xSavepoint, xRelease and xRollbackTo: 3.7.7 (2011-06-23) vtab = ["libsqlite3-sys/min_sqlite_version_3_7_16", "lazy_static"] -# xShadowName: 3.26.0 -vtab_v3 = ["vtab"] csvtab = ["csv", "vtab"] # pointer passing interfaces: 3.20.0 array = ["vtab"] From 168821a19dbdf9b157ba87cc0b13f44d2022e92f Mon Sep 17 00:00:00 2001 From: gwenn Date: Tue, 11 Feb 2020 20:57:39 +0100 Subject: [PATCH 09/61] Revert changes on old bindgens --- .../bindgen-bindings/bindgen_3.6.8.rs | 3548 +++++-------- .../bindgen-bindings/bindgen_3.7.16.rs | 4431 ++++++----------- 2 files changed, 2622 insertions(+), 5357 deletions(-) diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8.rs index ca1961e96..3cd6b15d6 100644 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8.rs +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8.rs @@ -1,7 +1,7 @@ /* automatically generated by rust-bindgen */ pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 6usize] = b"3.6.8\0"; +pub const SQLITE_VERSION: &'static [u8; 6usize] = b"3.6.8\x00"; pub const SQLITE_VERSION_NUMBER: i32 = 3006008; pub const SQLITE_OK: i32 = 0; pub const SQLITE_ERROR: i32 = 1; @@ -196,7 +196,7 @@ pub const SQLITE_STMTSTATUS_SORT: i32 = 2; pub type va_list = __builtin_va_list; pub type __gnuc_va_list = __builtin_va_list; extern "C" { - #[link_name = "\u{1}sqlite3_version"] + #[link_name = "sqlite3_version"] pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; } extern "C" { @@ -210,9 +210,7 @@ extern "C" { } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3 { - _unused: [u8; 0], -} +pub struct sqlite3([u8; 0]); pub type sqlite_int64 = ::std::os::raw::c_longlong; pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; pub type sqlite3_int64 = sqlite_int64; @@ -220,283 +218,133 @@ pub type sqlite3_uint64 = sqlite_uint64; extern "C" { pub fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int; } -pub type sqlite3_callback = ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, ->; -extern "C" { - pub fn sqlite3_exec( - arg1: *mut sqlite3, - sql: *const ::std::os::raw::c_char, - callback: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg2: *mut ::std::os::raw::c_void, - errmsg: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; +pub type sqlite3_callback = + ::std::option::Option ::std::os::raw::c_int>; +extern "C" { + pub fn sqlite3_exec(arg1: *mut sqlite3, + sql: *const ::std::os::raw::c_char, + callback: + ::std::option::Option + ::std::os::raw::c_int>, + arg2: *mut ::std::os::raw::c_void, + errmsg: *mut *mut ::std::os::raw::c_char) + -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy)] pub struct sqlite3_file { - pub pMethods: *const sqlite3_io_methods, -} -#[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_file)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_file)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_file), - "::", - stringify!(pMethods) - ) - ); + pub pMethods: *const sqlite3_file_sqlite3_io_methods, } #[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_io_methods { +#[derive(Debug, Copy)] +pub struct sqlite3_file_sqlite3_io_methods { pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xRead: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *mut ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xWrite: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *const ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pSize: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xUnlock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCheckReservedLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileControl: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - op: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xSectorSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xDeviceCharacteristics: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, + pub xClose: ::std::option::Option ::std::os::raw::c_int>, + pub xRead: ::std::option::Option ::std::os::raw::c_int>, + pub xWrite: ::std::option::Option ::std::os::raw::c_int>, + pub xTruncate: ::std::option::Option ::std::os::raw::c_int>, + pub xSync: ::std::option::Option ::std::os::raw::c_int>, + pub xFileSize: ::std::option::Option ::std::os::raw::c_int>, + pub xLock: ::std::option::Option ::std::os::raw::c_int>, + pub xUnlock: ::std::option::Option ::std::os::raw::c_int>, + pub xCheckReservedLock: ::std::option::Option + ::std::os::raw::c_int>, + pub xFileControl: ::std::option::Option ::std::os::raw::c_int>, + pub xSectorSize: ::std::option::Option ::std::os::raw::c_int>, + pub xDeviceCharacteristics: ::std::option::Option + ::std::os::raw::c_int>, } #[test] -fn bindgen_test_layout_sqlite3_io_methods() { - assert_eq!( - ::std::mem::size_of::(), - 104usize, - concat!("Size of: ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xRead) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xWrite) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnlock) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xCheckReservedLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileControl) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSectorSize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ - as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xDeviceCharacteristics) - ) - ); +fn bindgen_test_layout_sqlite3_file_sqlite3_io_methods() { + assert_eq!(::std::mem::size_of::() , + 104usize); + assert_eq!(::std::mem::align_of::() , + 8usize); } -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex { - _unused: [u8; 0], +impl Clone for sqlite3_file_sqlite3_io_methods { + fn clone(&self) -> Self { *self } +} +#[test] +fn bindgen_test_layout_sqlite3_file() { + assert_eq!(::std::mem::size_of::() , 8usize); + assert_eq!(::std::mem::align_of::() , 8usize); +} +impl Clone for sqlite3_file { + fn clone(&self) -> Self { *self } } +pub type sqlite3_io_methods = sqlite3_file_sqlite3_io_methods; #[repr(C)] #[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex([u8; 0]); +#[repr(C)] +#[derive(Debug, Copy)] pub struct sqlite3_vfs { pub iVersion: ::std::os::raw::c_int, pub szOsFile: ::std::os::raw::c_int, @@ -504,283 +352,97 @@ pub struct sqlite3_vfs { pub pNext: *mut sqlite3_vfs, pub zName: *const ::std::os::raw::c_char, pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - pOutFlags: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - syncDir: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xAccess: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - flags: ::std::os::raw::c_int, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFullPathname: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - nOut: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xDlOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zFilename: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void, - >, - pub xDlError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zErrMsg: *mut ::std::os::raw::c_char, - ), - >, - pub xDlSym: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ) -> ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ), - >, - >, - pub xDlClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), - >, - pub xRandomness: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSleep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - microseconds: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTime: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, - >, - pub xGetLastError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, + pub xOpen: ::std::option::Option ::std::os::raw::c_int>, + pub xDelete: ::std::option::Option ::std::os::raw::c_int>, + pub xAccess: ::std::option::Option ::std::os::raw::c_int>, + pub xFullPathname: ::std::option::Option ::std::os::raw::c_int>, + pub xDlOpen: ::std::option::Option *mut ::std::os::raw::c_void>, + pub xDlError: ::std::option::Option, + pub xDlSym: ::std::option::Option + ::std::option::Option>, + pub xDlClose: ::std::option::Option, + pub xRandomness: ::std::option::Option ::std::os::raw::c_int>, + pub xSleep: ::std::option::Option ::std::os::raw::c_int>, + pub xCurrentTime: ::std::option::Option ::std::os::raw::c_int>, + pub xGetLastError: ::std::option::Option ::std::os::raw::c_int>, } #[test] fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!( - ::std::mem::size_of::(), - 136usize, - concat!("Size of: ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(szOsFile) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(mxPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(zName) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pAppData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xAccess) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xFullPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlSym) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xRandomness) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSleep) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTime) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetLastError) - ) - ); + assert_eq!(::std::mem::size_of::() , 136usize); + assert_eq!(::std::mem::align_of::() , 8usize); +} +impl Clone for sqlite3_vfs { + fn clone(&self) -> Self { *self } } extern "C" { pub fn sqlite3_initialize() -> ::std::os::raw::c_int; @@ -795,138 +457,52 @@ extern "C" { pub fn sqlite3_os_end() -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; + pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_db_config( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int; + pub fn sqlite3_db_config(arg1: *mut sqlite3, + op: ::std::os::raw::c_int, ...) + -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy)] pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xRoundup: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, + pub xMalloc: ::std::option::Option *mut ::std::os::raw::c_void>, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option *mut ::std::os::raw::c_void>, + pub xSize: ::std::option::Option ::std::os::raw::c_int>, + pub xRoundup: ::std::option::Option ::std::os::raw::c_int>, + pub xInit: ::std::option::Option ::std::os::raw::c_int>, + pub xShutdown: ::std::option::Option, pub pAppData: *mut ::std::os::raw::c_void, } #[test] fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!( - ::std::mem::size_of::(), - 64usize, - concat!("Size of: ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xMalloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xFree) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRealloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRoundup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(pAppData) - ) - ); -} -extern "C" { - pub fn sqlite3_extended_result_codes( - arg1: *mut sqlite3, - onoff: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + assert_eq!(::std::mem::size_of::() , 64usize); + assert_eq!(::std::mem::align_of::() , 8usize); +} +impl Clone for sqlite3_mem_methods { + fn clone(&self) -> Self { *self } +} +extern "C" { + pub fn sqlite3_extended_result_codes(arg1: *mut sqlite3, + onoff: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite3_int64; @@ -941,68 +517,64 @@ extern "C" { pub fn sqlite3_interrupt(arg1: *mut sqlite3); } extern "C" { - pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; + pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int; + pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_busy_handler( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_busy_handler(arg1: *mut sqlite3, + arg2: + ::std::option::Option + ::std::os::raw::c_int>, + arg3: *mut ::std::os::raw::c_void) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_busy_timeout( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_busy_timeout(arg1: *mut sqlite3, ms: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_get_table( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - pazResult: *mut *mut *mut ::std::os::raw::c_char, - pnRow: *mut ::std::os::raw::c_int, - pnColumn: *mut ::std::os::raw::c_int, - pzErrmsg: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_get_table(db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + pazResult: *mut *mut *mut ::std::os::raw::c_char, + pnRow: *mut ::std::os::raw::c_int, + pnColumn: *mut ::std::os::raw::c_int, + pzErrmsg: *mut *mut ::std::os::raw::c_char) + -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char); } extern "C" { pub fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char, ...) - -> *mut ::std::os::raw::c_char; + -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_vmprintf( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char; + pub fn sqlite3_vmprintf(arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag) + -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_snprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char; + pub fn sqlite3_snprintf(arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, ...) + -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void; + pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) + -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_realloc( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void; + pub fn sqlite3_realloc(arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int) + -> *mut ::std::os::raw::c_void; } extern "C" { pub fn sqlite3_free(arg1: *mut ::std::os::raw::c_void); @@ -1011,433 +583,406 @@ extern "C" { pub fn sqlite3_memory_used() -> sqlite3_int64; } extern "C" { - pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) -> sqlite3_int64; + pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) + -> sqlite3_int64; } extern "C" { - pub fn sqlite3_randomness(N: ::std::os::raw::c_int, P: *mut ::std::os::raw::c_void); + pub fn sqlite3_randomness(N: ::std::os::raw::c_int, + P: *mut ::std::os::raw::c_void); } extern "C" { - pub fn sqlite3_set_authorizer( - arg1: *mut sqlite3, - xAuth: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pUserData: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_set_authorizer(arg1: *mut sqlite3, + xAuth: + ::std::option::Option + ::std::os::raw::c_int>, + pUserData: *mut ::std::os::raw::c_void) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_trace( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; + pub fn sqlite3_trace(arg1: *mut sqlite3, + xTrace: + ::std::option::Option, + arg2: *mut ::std::os::raw::c_void) + -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_profile( - arg1: *mut sqlite3, - xProfile: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_uint64, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; + pub fn sqlite3_profile(arg1: *mut sqlite3, + xProfile: + ::std::option::Option, + arg2: *mut ::std::os::raw::c_void) + -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_progress_handler( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, - ); + pub fn sqlite3_progress_handler(arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: + ::std::option::Option + ::std::os::raw::c_int>, + arg4: *mut ::std::os::raw::c_void); } extern "C" { - pub fn sqlite3_open( - filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_open(filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_open16( - filename: *const ::std::os::raw::c_void, - ppDb: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_open16(filename: *const ::std::os::raw::c_void, + ppDb: *mut *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_open_v2( - filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3, - flags: ::std::os::raw::c_int, - zVfs: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_open_v2(filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3, + flags: ::std::os::raw::c_int, + zVfs: *const ::std::os::raw::c_char) + -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_extended_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; + pub fn sqlite3_extended_errcode(db: *mut sqlite3) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char; + pub fn sqlite3_errmsg(arg1: *mut sqlite3) + -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void; + pub fn sqlite3_errmsg16(arg1: *mut sqlite3) + -> *const ::std::os::raw::c_void; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt { - _unused: [u8; 0], -} +pub struct sqlite3_stmt([u8; 0]); extern "C" { - pub fn sqlite3_limit( - arg1: *mut sqlite3, - id: ::std::os::raw::c_int, - newVal: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_limit(arg1: *mut sqlite3, id: ::std::os::raw::c_int, + newVal: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_prepare(db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare_v2( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_prepare_v2(db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare16( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_prepare16(db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare16_v2( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_prepare16_v2(db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char; + pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) + -> *const ::std::os::raw::c_char; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct Mem { - _unused: [u8; 0], -} +pub struct Mem([u8; 0]); pub type sqlite3_value = Mem; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_context { - _unused: [u8; 0], -} +pub struct sqlite3_context([u8; 0]); extern "C" { - pub fn sqlite3_bind_blob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_blob(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: + ::std::option::Option) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_double( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_double(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, arg3: f64) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_int( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_int(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_int64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_int64, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_int64(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_int64) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_null( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_null(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_text( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_text(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: + ::std::option::Option) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_text16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_text16(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: + ::std::option::Option) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_value( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_value(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_zeroblob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - n: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_zeroblob(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + n: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_parameter_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; + pub fn sqlite3_bind_parameter_name(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_bind_parameter_index( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_parameter_index(arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; + pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; + pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_name( - arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_name(arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_name16( - arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_name16(arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_database_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_database_name(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_database_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_database_name16(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_table_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_table_name(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_table_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_table_name16(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_origin_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_origin_name(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_origin_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_origin_name16(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_decltype( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_decltype(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_decltype16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_decltype16(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_void; } extern "C" { pub fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; + pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_blob( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_blob(arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_bytes( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_column_bytes(arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_bytes16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_column_bytes16(arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64; + pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int) -> f64; } extern "C" { - pub fn sqlite3_column_int( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_column_int(arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_int64( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> sqlite3_int64; + pub fn sqlite3_column_int64(arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int) -> sqlite3_int64; } extern "C" { - pub fn sqlite3_column_text( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_uchar; + pub fn sqlite3_column_text(arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_uchar; } extern "C" { - pub fn sqlite3_column_text16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_text16(arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_type( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_column_type(arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_value( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *mut sqlite3_value; + pub fn sqlite3_column_value(arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int) + -> *mut sqlite3_value; } extern "C" { - pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; + pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) + -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_create_function( - db: *mut sqlite3, - zFunctionName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function16( - db: *mut sqlite3, - zFunctionName: *const ::std::os::raw::c_void, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int; + pub fn sqlite3_create_function(db: *mut sqlite3, + zFunctionName: + *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: + ::std::option::Option, + xStep: + ::std::option::Option, + xFinal: + ::std::option::Option) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function16(db: *mut sqlite3, + zFunctionName: + *const ::std::os::raw::c_void, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: + ::std::option::Option, + xStep: + ::std::option::Option, + xFinal: + ::std::option::Option) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) + -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_transfer_bindings( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_transfer_bindings(arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt) + -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_global_recover() -> ::std::os::raw::c_int; @@ -1446,106 +991,111 @@ extern "C" { pub fn sqlite3_thread_cleanup(); } extern "C" { - pub fn sqlite3_memory_alarm( - arg1: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: sqlite3_int64, - arg3: ::std::os::raw::c_int, - ), - >, - arg2: *mut ::std::os::raw::c_void, - arg3: sqlite3_int64, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_memory_alarm(arg1: + ::std::option::Option, + arg2: *mut ::std::os::raw::c_void, + arg3: sqlite3_int64) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) + -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; + pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; + pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) + -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64; } extern "C" { - pub fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; + pub fn sqlite3_value_int(arg1: *mut sqlite3_value) + -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite3_int64; } extern "C" { - pub fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar; + pub fn sqlite3_value_text(arg1: *mut sqlite3_value) + -> *const ::std::os::raw::c_uchar; } extern "C" { - pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) + -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) + -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) + -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; + pub fn sqlite3_value_type(arg1: *mut sqlite3_value) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; + pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_aggregate_context( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void; + pub fn sqlite3_aggregate_context(arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int) + -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void; + pub fn sqlite3_user_data(arg1: *mut sqlite3_context) + -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3; + pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) + -> *mut sqlite3; } extern "C" { - pub fn sqlite3_get_auxdata( - arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void; + pub fn sqlite3_get_auxdata(arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int) + -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_set_auxdata( - arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option, - ); + pub fn sqlite3_set_auxdata(arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + arg3: + ::std::option::Option); } pub type sqlite3_destructor_type = - ::std::option::Option; + ::std::option::Option; extern "C" { - pub fn sqlite3_result_blob( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); + pub fn sqlite3_result_blob(arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: + ::std::option::Option); } extern "C" { pub fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64); } extern "C" { - pub fn sqlite3_result_error( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ); + pub fn sqlite3_result_error(arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_result_error16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - ); + pub fn sqlite3_result_error16(arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int); } extern "C" { pub fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context); @@ -1554,570 +1104,280 @@ extern "C" { pub fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context); } extern "C" { - pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); + pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); + pub fn sqlite3_result_int(arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite3_int64); + pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, + arg2: sqlite3_int64); } extern "C" { pub fn sqlite3_result_null(arg1: *mut sqlite3_context); } extern "C" { - pub fn sqlite3_result_text( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_text16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_text16le( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_text16be( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value); -} -extern "C" { - pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, n: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_create_collation( - arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - xCompare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation_v2( - arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - xCompare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation16( - arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_void, - eTextRep: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - xCompare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed16( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_key( - db: *mut sqlite3, - pKey: *const ::std::os::raw::c_void, - nKey: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_rekey( - db: *mut sqlite3, - pKey: *const ::std::os::raw::c_void, - nKey: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; -} -extern "C" { - #[link_name = "\u{1}sqlite3_temp_directory"] + pub fn sqlite3_result_text(arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: + ::std::option::Option); +} +extern "C" { + pub fn sqlite3_result_text16(arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: + ::std::option::Option); +} +extern "C" { + pub fn sqlite3_result_text16le(arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: + ::std::option::Option); +} +extern "C" { + pub fn sqlite3_result_text16be(arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: + ::std::option::Option); +} +extern "C" { + pub fn sqlite3_result_value(arg1: *mut sqlite3_context, + arg2: *mut sqlite3_value); +} +extern "C" { + pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, + n: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_create_collation(arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + xCompare: + ::std::option::Option + ::std::os::raw::c_int>) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation_v2(arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + xCompare: + ::std::option::Option + ::std::os::raw::c_int>, + xDestroy: + ::std::option::Option) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation16(arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_void, + eTextRep: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + xCompare: + ::std::option::Option + ::std::os::raw::c_int>) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed(arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: + ::std::option::Option) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed16(arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: + ::std::option::Option) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_key(db: *mut sqlite3, pKey: *const ::std::os::raw::c_void, + nKey: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_rekey(db: *mut sqlite3, + pKey: *const ::std::os::raw::c_void, + nKey: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "sqlite3_temp_directory"] pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int; + pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) + -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3; } extern "C" { - pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) -> *mut sqlite3_stmt; + pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) + -> *mut sqlite3_stmt; } extern "C" { - pub fn sqlite3_commit_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; + pub fn sqlite3_commit_hook(arg1: *mut sqlite3, + arg2: + ::std::option::Option + ::std::os::raw::c_int>, + arg3: *mut ::std::os::raw::c_void) + -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_rollback_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; + pub fn sqlite3_rollback_hook(arg1: *mut sqlite3, + arg2: + ::std::option::Option, + arg3: *mut ::std::os::raw::c_void) + -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_update_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; + pub fn sqlite3_update_hook(arg1: *mut sqlite3, + arg2: + ::std::option::Option, + arg3: *mut ::std::os::raw::c_void) + -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; + pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; + pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_table_column_metadata( - db: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - zTableName: *const ::std::os::raw::c_char, - zColumnName: *const ::std::os::raw::c_char, - pzDataType: *mut *const ::std::os::raw::c_char, - pzCollSeq: *mut *const ::std::os::raw::c_char, - pNotNull: *mut ::std::os::raw::c_int, - pPrimaryKey: *mut ::std::os::raw::c_int, - pAutoinc: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_table_column_metadata(db: *mut sqlite3, + zDbName: + *const ::std::os::raw::c_char, + zTableName: + *const ::std::os::raw::c_char, + zColumnName: + *const ::std::os::raw::c_char, + pzDataType: + *mut *const ::std::os::raw::c_char, + pzCollSeq: + *mut *const ::std::os::raw::c_char, + pNotNull: *mut ::std::os::raw::c_int, + pPrimaryKey: + *mut ::std::os::raw::c_int, + pAutoinc: *mut ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_load_extension( - db: *mut sqlite3, - zFile: *const ::std::os::raw::c_char, - zProc: *const ::std::os::raw::c_char, - pzErrMsg: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_load_extension(db: *mut sqlite3, + zFile: *const ::std::os::raw::c_char, + zProc: *const ::std::os::raw::c_char, + pzErrMsg: *mut *mut ::std::os::raw::c_char) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_enable_load_extension( - db: *mut sqlite3, - onoff: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_enable_load_extension(db: *mut sqlite3, + onoff: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_auto_extension( - xEntryPoint: ::std::option::Option, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_auto_extension(xEntryPoint: + ::std::option::Option) + -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_reset_auto_extension(); } #[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xConnect: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xBestIndex: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: *mut sqlite3_index_info, - ) -> ::std::os::raw::c_int, - >, - pub xDisconnect: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xDestroy: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - ppCursor: *mut *mut sqlite3_vtab_cursor, - ) -> ::std::os::raw::c_int, - >, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xFilter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - idxNum: ::std::os::raw::c_int, - idxStr: *const ::std::os::raw::c_char, - argc: ::std::os::raw::c_int, - argv: *mut *mut sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub xNext: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xEof: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - arg2: *mut sqlite3_context, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - pRowid: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xUpdate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - arg4: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xBegin: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xCommit: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xRollback: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xFindFunction: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - nArg: ::std::os::raw::c_int, - zName: *const ::std::os::raw::c_char, - pxFunc: *mut ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - ppArg: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xRename: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - zNew: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, +#[derive(Debug, Copy)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, } #[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!( - ::std::mem::size_of::(), - 160usize, - concat!("Size of: ", stringify!(sqlite3_module)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_module)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xConnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBestIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDisconnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFilter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xEof) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xColumn) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xUpdate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBegin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCommit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollback) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFindFunction) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRename) - ) - ); +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!(::std::mem::size_of::() , 24usize); + assert_eq!(::std::mem::align_of::() , 8usize); +} +impl Clone for sqlite3_vtab { + fn clone(&self) -> Self { *self } } #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy)] pub struct sqlite3_index_info { pub nConstraint: ::std::os::raw::c_int, pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, @@ -2131,7 +1391,7 @@ pub struct sqlite3_index_info { pub estimatedCost: f64, } #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy)] pub struct sqlite3_index_info_sqlite3_index_constraint { pub iColumn: ::std::os::raw::c_int, pub op: ::std::os::raw::c_uchar, @@ -2140,458 +1400,275 @@ pub struct sqlite3_index_info_sqlite3_index_constraint { } #[test] fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).op as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(op) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).usable - as *const _ as usize - }, - 5usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(usable) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iTermOffset - as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iTermOffset) - ) - ); + assert_eq!(::std::mem::size_of::() + , 12usize); + assert_eq!(::std::mem::align_of::() + , 4usize); +} +impl Clone for sqlite3_index_info_sqlite3_index_constraint { + fn clone(&self) -> Self { *self } } #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy)] pub struct sqlite3_index_info_sqlite3_index_orderby { pub iColumn: ::std::os::raw::c_int, pub desc: ::std::os::raw::c_uchar, } #[test] fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).desc as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(desc) - ) - ); + assert_eq!(::std::mem::size_of::() + , 8usize); + assert_eq!(::std::mem::align_of::() + , 4usize); +} +impl Clone for sqlite3_index_info_sqlite3_index_orderby { + fn clone(&self) -> Self { *self } } #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy)] pub struct sqlite3_index_info_sqlite3_index_constraint_usage { pub argvIndex: ::std::os::raw::c_int, pub omit: ::std::os::raw::c_uchar, } #[test] fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).argvIndex - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(argvIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).omit - as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(omit) - ) - ); + assert_eq!(::std::mem::size_of::() + , 8usize); + assert_eq!(::std::mem::align_of::() + , 4usize); +} +impl Clone for sqlite3_index_info_sqlite3_index_constraint_usage { + fn clone(&self) -> Self { *self } } #[test] fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nOrderBy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aOrderBy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraintUsage) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxNum) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(needToFreeIdxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(orderByConsumed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedCost as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedCost) - ) - ); -} -extern "C" { - pub fn sqlite3_create_module( - db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - arg1: *const sqlite3_module, - arg2: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_module_v2( - db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - arg1: *const sqlite3_module, - arg2: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, + assert_eq!(::std::mem::size_of::() , 72usize); + assert_eq!(::std::mem::align_of::() , 8usize); } -#[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(pModule) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(nRef) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(zErrMsg) - ) - ); +impl Clone for sqlite3_index_info { + fn clone(&self) -> Self { *self } } #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy)] pub struct sqlite3_vtab_cursor { pub pVtab: *mut sqlite3_vtab, } #[test] fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab_cursor), - "::", - stringify!(pVtab) - ) - ); -} -extern "C" { - pub fn sqlite3_declare_vtab( - arg1: *mut sqlite3, - zCreateTable: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_overload_function( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + assert_eq!(::std::mem::size_of::() , 8usize); + assert_eq!(::std::mem::align_of::() , 8usize); +} +impl Clone for sqlite3_vtab_cursor { + fn clone(&self) -> Self { *self } } #[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob { - _unused: [u8; 0], +#[derive(Debug, Copy)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option ::std::os::raw::c_int>, + pub xConnect: ::std::option::Option ::std::os::raw::c_int>, + pub xBestIndex: ::std::option::Option ::std::os::raw::c_int>, + pub xDisconnect: ::std::option::Option ::std::os::raw::c_int>, + pub xDestroy: ::std::option::Option ::std::os::raw::c_int>, + pub xOpen: ::std::option::Option ::std::os::raw::c_int>, + pub xClose: ::std::option::Option ::std::os::raw::c_int>, + pub xFilter: ::std::option::Option ::std::os::raw::c_int>, + pub xNext: ::std::option::Option ::std::os::raw::c_int>, + pub xEof: ::std::option::Option ::std::os::raw::c_int>, + pub xColumn: ::std::option::Option ::std::os::raw::c_int>, + pub xRowid: ::std::option::Option ::std::os::raw::c_int>, + pub xUpdate: ::std::option::Option ::std::os::raw::c_int>, + pub xBegin: ::std::option::Option ::std::os::raw::c_int>, + pub xSync: ::std::option::Option ::std::os::raw::c_int>, + pub xCommit: ::std::option::Option ::std::os::raw::c_int>, + pub xRollback: ::std::option::Option ::std::os::raw::c_int>, + pub xFindFunction: ::std::option::Option, + ppArg: + *mut *mut ::std::os::raw::c_void) + -> ::std::os::raw::c_int>, + pub xRename: ::std::option::Option ::std::os::raw::c_int>, +} +#[test] +fn bindgen_test_layout_sqlite3_module() { + assert_eq!(::std::mem::size_of::() , 160usize); + assert_eq!(::std::mem::align_of::() , 8usize); +} +impl Clone for sqlite3_module { + fn clone(&self) -> Self { *self } +} +extern "C" { + pub fn sqlite3_create_module(db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + arg1: *const sqlite3_module, + arg2: *mut ::std::os::raw::c_void) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_module_v2(db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + arg1: *const sqlite3_module, + arg2: *mut ::std::os::raw::c_void, + xDestroy: + ::std::option::Option) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_open( - arg1: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - zTable: *const ::std::os::raw::c_char, - zColumn: *const ::std::os::raw::c_char, - iRow: sqlite3_int64, - flags: ::std::os::raw::c_int, - ppBlob: *mut *mut sqlite3_blob, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_declare_vtab(arg1: *mut sqlite3, + zCreateTable: *const ::std::os::raw::c_char) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; + pub fn sqlite3_overload_function(arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_blob([u8; 0]); +extern "C" { + pub fn sqlite3_blob_open(arg1: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + zTable: *const ::std::os::raw::c_char, + zColumn: *const ::std::os::raw::c_char, + iRow: sqlite3_int64, + flags: ::std::os::raw::c_int, + ppBlob: *mut *mut sqlite3_blob) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; + pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_read( - arg1: *mut sqlite3_blob, - Z: *mut ::std::os::raw::c_void, - N: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_blob_read(arg1: *mut sqlite3_blob, + Z: *mut ::std::os::raw::c_void, + N: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_write( - arg1: *mut sqlite3_blob, - z: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_blob_write(arg1: *mut sqlite3_blob, + z: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs; + pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) + -> *mut sqlite3_vfs; } extern "C" { - pub fn sqlite3_vfs_register( - arg1: *mut sqlite3_vfs, - makeDflt: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_vfs_register(arg1: *mut sqlite3_vfs, + makeDflt: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int; + pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex; + pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) + -> *mut sqlite3_mutex; } extern "C" { pub fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex); @@ -2600,436 +1677,159 @@ extern "C" { pub fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex); } extern "C" { - pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; + pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) + -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex); } #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy)] pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexNotheld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option *mut sqlite3_mutex>, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexNotheld: ::std::option::Option ::std::os::raw::c_int>, } #[test] fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexInit as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnd) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexAlloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexFree as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexFree) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexTry) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexLeave) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexHeld) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexNotheld) - ) - ); -} -extern "C" { - pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; + assert_eq!(::std::mem::size_of::() , 72usize); + assert_eq!(::std::mem::align_of::() , 8usize); +} +impl Clone for sqlite3_mutex_methods { + fn clone(&self) -> Self { *self } +} +extern "C" { + pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) + -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex; } extern "C" { - pub fn sqlite3_file_control( - arg1: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - op: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_file_control(arg1: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + op: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; + pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_status( - op: ::std::os::raw::c_int, - pCurrent: *mut ::std::os::raw::c_int, - pHighwater: *mut ::std::os::raw::c_int, - resetFlag: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_status(op: ::std::os::raw::c_int, + pCurrent: *mut ::std::os::raw::c_int, + pHighwater: *mut ::std::os::raw::c_int, + resetFlag: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_db_status( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - pCur: *mut ::std::os::raw::c_int, - pHiwtr: *mut ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_db_status(arg1: *mut sqlite3, op: ::std::os::raw::c_int, + pCur: *mut ::std::os::raw::c_int, + pHiwtr: *mut ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_stmt_status( - arg1: *mut sqlite3_stmt, - op: ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_stmt_status(arg1: *mut sqlite3_stmt, + op: ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache { - _unused: [u8; 0], -} +pub struct sqlite3_pcache([u8; 0]); #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy)] pub struct sqlite3_pcache_methods { pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, + pub xInit: ::std::option::Option ::std::os::raw::c_int>, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option *mut sqlite3_pcache>, + pub xCachesize: ::std::option::Option, + pub xPagecount: ::std::option::Option ::std::os::raw::c_int>, + pub xFetch: ::std::option::Option *mut ::std::os::raw::c_void>, + pub xUnpin: ::std::option::Option, + pub xRekey: ::std::option::Option, + pub xTruncate: ::std::option::Option, + pub xDestroy: ::std::option::Option, } #[test] fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!( - ::std::mem::size_of::(), - 88usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xDestroy) - ) - ); + assert_eq!(::std::mem::size_of::() , 88usize); + assert_eq!(::std::mem::align_of::() , 8usize); +} +impl Clone for sqlite3_pcache_methods { + fn clone(&self) -> Self { *self } } -pub type __builtin_va_list = [__va_list_tag; 1usize]; #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy)] pub struct __va_list_tag { pub gp_offset: ::std::os::raw::c_uint, pub fp_offset: ::std::os::raw::c_uint, pub overflow_arg_area: *mut ::std::os::raw::c_void, pub reg_save_area: *mut ::std::os::raw::c_void, } -#[test] -fn bindgen_test_layout___va_list_tag() { - assert_eq!( - ::std::mem::size_of::<__va_list_tag>(), - 24usize, - concat!("Size of: ", stringify!(__va_list_tag)) - ); - assert_eq!( - ::std::mem::align_of::<__va_list_tag>(), - 8usize, - concat!("Alignment of ", stringify!(__va_list_tag)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(gp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(fp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(overflow_arg_area) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(reg_save_area) - ) - ); +impl Clone for __va_list_tag { + fn clone(&self) -> Self { *self } } +pub type __builtin_va_list = [__va_list_tag; 1usize]; + pub const SQLITE_DETERMINISTIC: i32 = 2048; diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16.rs index 095987694..cd1489511 100644 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16.rs +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16.rs @@ -1,10 +1,10 @@ /* automatically generated by rust-bindgen */ pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.7.16\0"; +pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.7.16\x00"; pub const SQLITE_VERSION_NUMBER: i32 = 3007016; pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = - b"2013-03-18 11:39:23 66d5f2b76750f3520eb7a495f6247206758f5b90\0"; + b"2013-03-18 11:39:23 66d5f2b76750f3520eb7a495f6247206758f5b90\x00"; pub const SQLITE_OK: i32 = 0; pub const SQLITE_ERROR: i32 = 1; pub const SQLITE_INTERNAL: i32 = 2; @@ -289,7 +289,7 @@ pub const SQLITE_REPLACE: i32 = 5; pub type va_list = __builtin_va_list; pub type __gnuc_va_list = __builtin_va_list; extern "C" { - #[link_name = "\u{1}sqlite3_version"] + #[link_name = "sqlite3_version"] pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; } extern "C" { @@ -302,21 +302,19 @@ extern "C" { pub fn sqlite3_libversion_number() -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_compileoption_used( - zOptName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_compileoption_used(zOptName: *const ::std::os::raw::c_char) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_compileoption_get(N: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; + pub fn sqlite3_compileoption_get(N: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_char; } extern "C" { pub fn sqlite3_threadsafe() -> ::std::os::raw::c_int; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3 { - _unused: [u8; 0], -} +pub struct sqlite3([u8; 0]); pub type sqlite_int64 = ::std::os::raw::c_longlong; pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; pub type sqlite3_int64 = sqlite_int64; @@ -327,348 +325,160 @@ extern "C" { extern "C" { pub fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int; } -pub type sqlite3_callback = ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, ->; -extern "C" { - pub fn sqlite3_exec( - arg1: *mut sqlite3, - sql: *const ::std::os::raw::c_char, - callback: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg2: *mut ::std::os::raw::c_void, - errmsg: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; +pub type sqlite3_callback = + ::std::option::Option ::std::os::raw::c_int>; +extern "C" { + pub fn sqlite3_exec(arg1: *mut sqlite3, + sql: *const ::std::os::raw::c_char, + callback: + ::std::option::Option + ::std::os::raw::c_int>, + arg2: *mut ::std::os::raw::c_void, + errmsg: *mut *mut ::std::os::raw::c_char) + -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy)] pub struct sqlite3_file { - pub pMethods: *const sqlite3_io_methods, -} -#[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_file)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_file)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_file), - "::", - stringify!(pMethods) - ) - ); + pub pMethods: *const sqlite3_file_sqlite3_io_methods, } #[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_io_methods { +#[derive(Debug, Copy)] +pub struct sqlite3_file_sqlite3_io_methods { pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xRead: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *mut ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xWrite: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *const ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pSize: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xUnlock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCheckReservedLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileControl: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - op: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xSectorSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xDeviceCharacteristics: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xShmMap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iPg: ::std::os::raw::c_int, - pgsz: ::std::os::raw::c_int, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xShmLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - offset: ::std::os::raw::c_int, - n: ::std::os::raw::c_int, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xShmBarrier: ::std::option::Option, - pub xShmUnmap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - deleteFlag: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, + pub xClose: ::std::option::Option ::std::os::raw::c_int>, + pub xRead: ::std::option::Option ::std::os::raw::c_int>, + pub xWrite: ::std::option::Option ::std::os::raw::c_int>, + pub xTruncate: ::std::option::Option ::std::os::raw::c_int>, + pub xSync: ::std::option::Option ::std::os::raw::c_int>, + pub xFileSize: ::std::option::Option ::std::os::raw::c_int>, + pub xLock: ::std::option::Option ::std::os::raw::c_int>, + pub xUnlock: ::std::option::Option ::std::os::raw::c_int>, + pub xCheckReservedLock: ::std::option::Option + ::std::os::raw::c_int>, + pub xFileControl: ::std::option::Option ::std::os::raw::c_int>, + pub xSectorSize: ::std::option::Option ::std::os::raw::c_int>, + pub xDeviceCharacteristics: ::std::option::Option + ::std::os::raw::c_int>, + pub xShmMap: ::std::option::Option ::std::os::raw::c_int>, + pub xShmLock: ::std::option::Option ::std::os::raw::c_int>, + pub xShmBarrier: ::std::option::Option, + pub xShmUnmap: ::std::option::Option ::std::os::raw::c_int>, } #[test] -fn bindgen_test_layout_sqlite3_io_methods() { - assert_eq!( - ::std::mem::size_of::(), - 136usize, - concat!("Size of: ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xRead) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xWrite) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnlock) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xCheckReservedLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileControl) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSectorSize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ - as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xDeviceCharacteristics) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmMap) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmBarrier) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmUnmap) - ) - ); +fn bindgen_test_layout_sqlite3_file_sqlite3_io_methods() { + assert_eq!(::std::mem::size_of::() , + 136usize); + assert_eq!(::std::mem::align_of::() , + 8usize); } -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex { - _unused: [u8; 0], +impl Clone for sqlite3_file_sqlite3_io_methods { + fn clone(&self) -> Self { *self } } -pub type sqlite3_syscall_ptr = ::std::option::Option; +#[test] +fn bindgen_test_layout_sqlite3_file() { + assert_eq!(::std::mem::size_of::() , 8usize); + assert_eq!(::std::mem::align_of::() , 8usize); +} +impl Clone for sqlite3_file { + fn clone(&self) -> Self { *self } +} +pub type sqlite3_io_methods = sqlite3_file_sqlite3_io_methods; #[repr(C)] #[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex([u8; 0]); +#[repr(C)] +#[derive(Debug, Copy)] pub struct sqlite3_vfs { pub iVersion: ::std::os::raw::c_int, pub szOsFile: ::std::os::raw::c_int, @@ -676,349 +486,124 @@ pub struct sqlite3_vfs { pub pNext: *mut sqlite3_vfs, pub zName: *const ::std::os::raw::c_char, pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - pOutFlags: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - syncDir: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xAccess: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - flags: ::std::os::raw::c_int, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFullPathname: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - nOut: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xDlOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zFilename: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void, - >, - pub xDlError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zErrMsg: *mut ::std::os::raw::c_char, - ), - >, - pub xDlSym: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ) -> ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ), - >, - >, - pub xDlClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), - >, - pub xRandomness: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSleep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - microseconds: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTime: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, - >, - pub xGetLastError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTimeInt64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xSetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: sqlite3_syscall_ptr, - ) -> ::std::os::raw::c_int, - >, - pub xGetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> sqlite3_syscall_ptr, - >, - pub xNextSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, + pub xOpen: ::std::option::Option ::std::os::raw::c_int>, + pub xDelete: ::std::option::Option ::std::os::raw::c_int>, + pub xAccess: ::std::option::Option ::std::os::raw::c_int>, + pub xFullPathname: ::std::option::Option ::std::os::raw::c_int>, + pub xDlOpen: ::std::option::Option *mut ::std::os::raw::c_void>, + pub xDlError: ::std::option::Option, + pub xDlSym: ::std::option::Option + ::std::option::Option>, + pub xDlClose: ::std::option::Option, + pub xRandomness: ::std::option::Option ::std::os::raw::c_int>, + pub xSleep: ::std::option::Option ::std::os::raw::c_int>, + pub xCurrentTime: ::std::option::Option ::std::os::raw::c_int>, + pub xGetLastError: ::std::option::Option ::std::os::raw::c_int>, + pub xCurrentTimeInt64: ::std::option::Option + ::std::os::raw::c_int>, + pub xSetSystemCall: ::std::option::Option ::std::os::raw::c_int>, + pub xGetSystemCall: ::std::option::Option + ::std::option::Option>, + pub xNextSystemCall: ::std::option::Option + *const ::std::os::raw::c_char>, } #[test] fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!( - ::std::mem::size_of::(), - 168usize, - concat!("Size of: ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(szOsFile) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(mxPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(zName) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pAppData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xAccess) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xFullPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlSym) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xRandomness) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSleep) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTime) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetLastError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTimeInt64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xNextSystemCall) - ) - ); + assert_eq!(::std::mem::size_of::() , 168usize); + assert_eq!(::std::mem::align_of::() , 8usize); +} +impl Clone for sqlite3_vfs { + fn clone(&self) -> Self { *self } } +pub type sqlite3_syscall_ptr = ::std::option::Option; extern "C" { pub fn sqlite3_initialize() -> ::std::os::raw::c_int; } @@ -1032,138 +617,52 @@ extern "C" { pub fn sqlite3_os_end() -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; + pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_db_config( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int; + pub fn sqlite3_db_config(arg1: *mut sqlite3, + op: ::std::os::raw::c_int, ...) + -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy)] pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xRoundup: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, + pub xMalloc: ::std::option::Option *mut ::std::os::raw::c_void>, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option *mut ::std::os::raw::c_void>, + pub xSize: ::std::option::Option ::std::os::raw::c_int>, + pub xRoundup: ::std::option::Option ::std::os::raw::c_int>, + pub xInit: ::std::option::Option ::std::os::raw::c_int>, + pub xShutdown: ::std::option::Option, pub pAppData: *mut ::std::os::raw::c_void, } #[test] fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!( - ::std::mem::size_of::(), - 64usize, - concat!("Size of: ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xMalloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xFree) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRealloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRoundup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(pAppData) - ) - ); -} -extern "C" { - pub fn sqlite3_extended_result_codes( - arg1: *mut sqlite3, - onoff: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + assert_eq!(::std::mem::size_of::() , 64usize); + assert_eq!(::std::mem::align_of::() , 8usize); +} +impl Clone for sqlite3_mem_methods { + fn clone(&self) -> Self { *self } +} +extern "C" { + pub fn sqlite3_extended_result_codes(arg1: *mut sqlite3, + onoff: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite3_int64; @@ -1178,76 +677,71 @@ extern "C" { pub fn sqlite3_interrupt(arg1: *mut sqlite3); } extern "C" { - pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; + pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int; + pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_busy_handler( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_busy_handler(arg1: *mut sqlite3, + arg2: + ::std::option::Option + ::std::os::raw::c_int>, + arg3: *mut ::std::os::raw::c_void) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_busy_timeout( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_busy_timeout(arg1: *mut sqlite3, ms: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_get_table( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - pazResult: *mut *mut *mut ::std::os::raw::c_char, - pnRow: *mut ::std::os::raw::c_int, - pnColumn: *mut ::std::os::raw::c_int, - pzErrmsg: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_get_table(db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + pazResult: *mut *mut *mut ::std::os::raw::c_char, + pnRow: *mut ::std::os::raw::c_int, + pnColumn: *mut ::std::os::raw::c_int, + pzErrmsg: *mut *mut ::std::os::raw::c_char) + -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char); } extern "C" { pub fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char, ...) - -> *mut ::std::os::raw::c_char; + -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_vmprintf( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char; + pub fn sqlite3_vmprintf(arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag) + -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_snprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char; + pub fn sqlite3_snprintf(arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, ...) + -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_vsnprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char; + pub fn sqlite3_vsnprintf(arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag) + -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void; + pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) + -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_realloc( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void; + pub fn sqlite3_realloc(arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int) + -> *mut ::std::os::raw::c_void; } extern "C" { pub fn sqlite3_free(arg1: *mut ::std::os::raw::c_void); @@ -1256,487 +750,463 @@ extern "C" { pub fn sqlite3_memory_used() -> sqlite3_int64; } extern "C" { - pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) -> sqlite3_int64; + pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) + -> sqlite3_int64; } extern "C" { - pub fn sqlite3_randomness(N: ::std::os::raw::c_int, P: *mut ::std::os::raw::c_void); + pub fn sqlite3_randomness(N: ::std::os::raw::c_int, + P: *mut ::std::os::raw::c_void); } extern "C" { - pub fn sqlite3_set_authorizer( - arg1: *mut sqlite3, - xAuth: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pUserData: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_set_authorizer(arg1: *mut sqlite3, + xAuth: + ::std::option::Option + ::std::os::raw::c_int>, + pUserData: *mut ::std::os::raw::c_void) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_trace( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; + pub fn sqlite3_trace(arg1: *mut sqlite3, + xTrace: + ::std::option::Option, + arg2: *mut ::std::os::raw::c_void) + -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_profile( - arg1: *mut sqlite3, - xProfile: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_uint64, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; + pub fn sqlite3_profile(arg1: *mut sqlite3, + xProfile: + ::std::option::Option, + arg2: *mut ::std::os::raw::c_void) + -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_progress_handler( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, - ); + pub fn sqlite3_progress_handler(arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: + ::std::option::Option + ::std::os::raw::c_int>, + arg4: *mut ::std::os::raw::c_void); } extern "C" { - pub fn sqlite3_open( - filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_open(filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_open16( - filename: *const ::std::os::raw::c_void, - ppDb: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_open16(filename: *const ::std::os::raw::c_void, + ppDb: *mut *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_open_v2( - filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3, - flags: ::std::os::raw::c_int, - zVfs: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_open_v2(filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3, + flags: ::std::os::raw::c_int, + zVfs: *const ::std::os::raw::c_char) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_uri_parameter( - zFilename: *const ::std::os::raw::c_char, - zParam: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char; + pub fn sqlite3_uri_parameter(zFilename: *const ::std::os::raw::c_char, + zParam: *const ::std::os::raw::c_char) + -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_uri_boolean( - zFile: *const ::std::os::raw::c_char, - zParam: *const ::std::os::raw::c_char, - bDefault: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_uri_boolean(zFile: *const ::std::os::raw::c_char, + zParam: *const ::std::os::raw::c_char, + bDefault: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_uri_int64( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_int64, - ) -> sqlite3_int64; + pub fn sqlite3_uri_int64(arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64) -> sqlite3_int64; } extern "C" { pub fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_extended_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; + pub fn sqlite3_extended_errcode(db: *mut sqlite3) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char; + pub fn sqlite3_errmsg(arg1: *mut sqlite3) + -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void; + pub fn sqlite3_errmsg16(arg1: *mut sqlite3) + -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; + pub fn sqlite3_errstr(arg1: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_char; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt { - _unused: [u8; 0], -} +pub struct sqlite3_stmt([u8; 0]); extern "C" { - pub fn sqlite3_limit( - arg1: *mut sqlite3, - id: ::std::os::raw::c_int, - newVal: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_limit(arg1: *mut sqlite3, id: ::std::os::raw::c_int, + newVal: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_prepare(db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare_v2( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_prepare_v2(db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare16( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_prepare16(db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare16_v2( - db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_prepare16_v2(db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char; + pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) + -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_stmt_readonly(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; + pub fn sqlite3_stmt_readonly(pStmt: *mut sqlite3_stmt) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; + pub fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) + -> ::std::os::raw::c_int; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct Mem { - _unused: [u8; 0], -} +pub struct Mem([u8; 0]); pub type sqlite3_value = Mem; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_context { - _unused: [u8; 0], -} +pub struct sqlite3_context([u8; 0]); extern "C" { - pub fn sqlite3_bind_blob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_blob(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: + ::std::option::Option) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_double( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_double(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, arg3: f64) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_int( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_int(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_int64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_int64, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_int64(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_int64) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_null( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_null(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_text( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_text(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: + ::std::option::Option) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_text16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_text16(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: + ::std::option::Option) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_value( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_value(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_zeroblob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - n: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_zeroblob(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + n: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_parameter_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; + pub fn sqlite3_bind_parameter_name(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_bind_parameter_index( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_parameter_index(arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; + pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; + pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_name( - arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_name(arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_name16( - arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_name16(arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_database_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_database_name(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_database_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_database_name16(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_table_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_table_name(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_table_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_table_name16(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_origin_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_origin_name(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_origin_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_origin_name16(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_decltype( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_decltype(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_decltype16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_decltype16(arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_void; } extern "C" { pub fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; + pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_blob( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_blob(arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_bytes( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_column_bytes(arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_bytes16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_column_bytes16(arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64; + pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int) -> f64; } extern "C" { - pub fn sqlite3_column_int( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_column_int(arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_int64( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> sqlite3_int64; + pub fn sqlite3_column_int64(arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int) -> sqlite3_int64; } extern "C" { - pub fn sqlite3_column_text( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_uchar; + pub fn sqlite3_column_text(arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_uchar; } extern "C" { - pub fn sqlite3_column_text16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_text16(arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int) + -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_type( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_column_type(arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_value( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *mut sqlite3_value; + pub fn sqlite3_column_value(arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int) + -> *mut sqlite3_value; } extern "C" { - pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; + pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) + -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_create_function( - db: *mut sqlite3, - zFunctionName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function16( - db: *mut sqlite3, - zFunctionName: *const ::std::os::raw::c_void, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function_v2( - db: *mut sqlite3, - zFunctionName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int; + pub fn sqlite3_create_function(db: *mut sqlite3, + zFunctionName: + *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: + ::std::option::Option, + xStep: + ::std::option::Option, + xFinal: + ::std::option::Option) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function16(db: *mut sqlite3, + zFunctionName: + *const ::std::os::raw::c_void, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: + ::std::option::Option, + xStep: + ::std::option::Option, + xFinal: + ::std::option::Option) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function_v2(db: *mut sqlite3, + zFunctionName: + *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: + ::std::option::Option, + xStep: + ::std::option::Option, + xFinal: + ::std::option::Option, + xDestroy: + ::std::option::Option) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) + -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_transfer_bindings( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_transfer_bindings(arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt) + -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_global_recover() -> ::std::os::raw::c_int; @@ -1745,106 +1215,111 @@ extern "C" { pub fn sqlite3_thread_cleanup(); } extern "C" { - pub fn sqlite3_memory_alarm( - arg1: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: sqlite3_int64, - arg3: ::std::os::raw::c_int, - ), - >, - arg2: *mut ::std::os::raw::c_void, - arg3: sqlite3_int64, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_memory_alarm(arg1: + ::std::option::Option, + arg2: *mut ::std::os::raw::c_void, + arg3: sqlite3_int64) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) + -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; + pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; + pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) + -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64; } extern "C" { - pub fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; + pub fn sqlite3_value_int(arg1: *mut sqlite3_value) + -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite3_int64; } extern "C" { - pub fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar; + pub fn sqlite3_value_text(arg1: *mut sqlite3_value) + -> *const ::std::os::raw::c_uchar; } extern "C" { - pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) + -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) + -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) + -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; + pub fn sqlite3_value_type(arg1: *mut sqlite3_value) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; + pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_aggregate_context( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void; + pub fn sqlite3_aggregate_context(arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int) + -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void; + pub fn sqlite3_user_data(arg1: *mut sqlite3_context) + -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3; + pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) + -> *mut sqlite3; } extern "C" { - pub fn sqlite3_get_auxdata( - arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void; + pub fn sqlite3_get_auxdata(arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int) + -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_set_auxdata( - arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option, - ); + pub fn sqlite3_set_auxdata(arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + arg3: + ::std::option::Option); } pub type sqlite3_destructor_type = - ::std::option::Option; + ::std::option::Option; extern "C" { - pub fn sqlite3_result_blob( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); + pub fn sqlite3_result_blob(arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: + ::std::option::Option); } extern "C" { pub fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64); } extern "C" { - pub fn sqlite3_result_error( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ); + pub fn sqlite3_result_error(arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_result_error16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - ); + pub fn sqlite3_result_error16(arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int); } extern "C" { pub fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context); @@ -1853,206 +1328,229 @@ extern "C" { pub fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context); } extern "C" { - pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); + pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); + pub fn sqlite3_result_int(arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite3_int64); + pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, + arg2: sqlite3_int64); } extern "C" { pub fn sqlite3_result_null(arg1: *mut sqlite3_context); } extern "C" { - pub fn sqlite3_result_text( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_text16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_text16le( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_text16be( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ); -} -extern "C" { - pub fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value); -} -extern "C" { - pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, n: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_create_collation( - arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - xCompare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation_v2( - arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - xCompare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation16( - arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_void, - eTextRep: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - xCompare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed16( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; -} -extern "C" { - #[link_name = "\u{1}sqlite3_temp_directory"] + pub fn sqlite3_result_text(arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: + ::std::option::Option); +} +extern "C" { + pub fn sqlite3_result_text16(arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: + ::std::option::Option); +} +extern "C" { + pub fn sqlite3_result_text16le(arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: + ::std::option::Option); +} +extern "C" { + pub fn sqlite3_result_text16be(arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: + ::std::option::Option); +} +extern "C" { + pub fn sqlite3_result_value(arg1: *mut sqlite3_context, + arg2: *mut sqlite3_value); +} +extern "C" { + pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, + n: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_create_collation(arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + xCompare: + ::std::option::Option + ::std::os::raw::c_int>) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation_v2(arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + xCompare: + ::std::option::Option + ::std::os::raw::c_int>, + xDestroy: + ::std::option::Option) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation16(arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_void, + eTextRep: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + xCompare: + ::std::option::Option + ::std::os::raw::c_int>) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed(arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: + ::std::option::Option) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed16(arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: + ::std::option::Option) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; +} +extern "C" { + #[link_name = "sqlite3_temp_directory"] pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; } extern "C" { - #[link_name = "\u{1}sqlite3_data_directory"] + #[link_name = "sqlite3_data_directory"] pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int; + pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) + -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3; } extern "C" { - pub fn sqlite3_db_filename( - db: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char; + pub fn sqlite3_db_filename(db: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char) + -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_db_readonly( - db: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_db_readonly(db: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) -> *mut sqlite3_stmt; + pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) + -> *mut sqlite3_stmt; } extern "C" { - pub fn sqlite3_commit_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; + pub fn sqlite3_commit_hook(arg1: *mut sqlite3, + arg2: + ::std::option::Option + ::std::os::raw::c_int>, + arg3: *mut ::std::os::raw::c_void) + -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_rollback_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; + pub fn sqlite3_rollback_hook(arg1: *mut sqlite3, + arg2: + ::std::option::Option, + arg3: *mut ::std::os::raw::c_void) + -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_update_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; + pub fn sqlite3_update_hook(arg1: *mut sqlite3, + arg2: + ::std::option::Option, + arg3: *mut ::std::os::raw::c_void) + -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; + pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; + pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int; + pub fn sqlite3_db_release_memory(arg1: *mut sqlite3) + -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_soft_heap_limit64(N: sqlite3_int64) -> sqlite3_int64; @@ -2061,418 +1559,60 @@ extern "C" { pub fn sqlite3_soft_heap_limit(N: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_table_column_metadata( - db: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - zTableName: *const ::std::os::raw::c_char, - zColumnName: *const ::std::os::raw::c_char, - pzDataType: *mut *const ::std::os::raw::c_char, - pzCollSeq: *mut *const ::std::os::raw::c_char, - pNotNull: *mut ::std::os::raw::c_int, - pPrimaryKey: *mut ::std::os::raw::c_int, - pAutoinc: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_table_column_metadata(db: *mut sqlite3, + zDbName: + *const ::std::os::raw::c_char, + zTableName: + *const ::std::os::raw::c_char, + zColumnName: + *const ::std::os::raw::c_char, + pzDataType: + *mut *const ::std::os::raw::c_char, + pzCollSeq: + *mut *const ::std::os::raw::c_char, + pNotNull: *mut ::std::os::raw::c_int, + pPrimaryKey: + *mut ::std::os::raw::c_int, + pAutoinc: *mut ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_load_extension( - db: *mut sqlite3, - zFile: *const ::std::os::raw::c_char, - zProc: *const ::std::os::raw::c_char, - pzErrMsg: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_load_extension(db: *mut sqlite3, + zFile: *const ::std::os::raw::c_char, + zProc: *const ::std::os::raw::c_char, + pzErrMsg: *mut *mut ::std::os::raw::c_char) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_enable_load_extension( - db: *mut sqlite3, - onoff: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_enable_load_extension(db: *mut sqlite3, + onoff: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_auto_extension( - xEntryPoint: ::std::option::Option, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_auto_extension(xEntryPoint: + ::std::option::Option) + -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_reset_auto_extension(); } #[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xConnect: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xBestIndex: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: *mut sqlite3_index_info, - ) -> ::std::os::raw::c_int, - >, - pub xDisconnect: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xDestroy: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - ppCursor: *mut *mut sqlite3_vtab_cursor, - ) -> ::std::os::raw::c_int, - >, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xFilter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - idxNum: ::std::os::raw::c_int, - idxStr: *const ::std::os::raw::c_char, - argc: ::std::os::raw::c_int, - argv: *mut *mut sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub xNext: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xEof: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - arg2: *mut sqlite3_context, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - pRowid: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xUpdate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - arg4: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xBegin: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xCommit: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xRollback: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xFindFunction: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - nArg: ::std::os::raw::c_int, - zName: *const ::std::os::raw::c_char, - pxFunc: *mut ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - ppArg: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xRename: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - zNew: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSavepoint: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRelease: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRollbackTo: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, +#[derive(Debug, Copy)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, } #[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!( - ::std::mem::size_of::(), - 184usize, - concat!("Size of: ", stringify!(sqlite3_module)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_module)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xConnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBestIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDisconnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFilter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xEof) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xColumn) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xUpdate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBegin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCommit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollback) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFindFunction) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRename) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSavepoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRelease) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollbackTo) - ) - ); +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!(::std::mem::size_of::() , 24usize); + assert_eq!(::std::mem::align_of::() , 8usize); +} +impl Clone for sqlite3_vtab { + fn clone(&self) -> Self { *self } } #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy)] pub struct sqlite3_index_info { pub nConstraint: ::std::os::raw::c_int, pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, @@ -2486,7 +1626,7 @@ pub struct sqlite3_index_info { pub estimatedCost: f64, } #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy)] pub struct sqlite3_index_info_sqlite3_index_constraint { pub iColumn: ::std::os::raw::c_int, pub op: ::std::os::raw::c_uchar, @@ -2495,464 +1635,294 @@ pub struct sqlite3_index_info_sqlite3_index_constraint { } #[test] fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).op as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(op) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).usable - as *const _ as usize - }, - 5usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(usable) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iTermOffset - as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iTermOffset) - ) - ); + assert_eq!(::std::mem::size_of::() + , 12usize); + assert_eq!(::std::mem::align_of::() + , 4usize); +} +impl Clone for sqlite3_index_info_sqlite3_index_constraint { + fn clone(&self) -> Self { *self } } #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy)] pub struct sqlite3_index_info_sqlite3_index_orderby { pub iColumn: ::std::os::raw::c_int, pub desc: ::std::os::raw::c_uchar, } #[test] fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).desc as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(desc) - ) - ); + assert_eq!(::std::mem::size_of::() + , 8usize); + assert_eq!(::std::mem::align_of::() + , 4usize); +} +impl Clone for sqlite3_index_info_sqlite3_index_orderby { + fn clone(&self) -> Self { *self } } #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy)] pub struct sqlite3_index_info_sqlite3_index_constraint_usage { pub argvIndex: ::std::os::raw::c_int, pub omit: ::std::os::raw::c_uchar, } #[test] fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).argvIndex - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(argvIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).omit - as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(omit) - ) - ); + assert_eq!(::std::mem::size_of::() + , 8usize); + assert_eq!(::std::mem::align_of::() + , 4usize); +} +impl Clone for sqlite3_index_info_sqlite3_index_constraint_usage { + fn clone(&self) -> Self { *self } } #[test] fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nOrderBy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aOrderBy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraintUsage) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxNum) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(needToFreeIdxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(orderByConsumed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedCost as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedCost) - ) - ); -} -extern "C" { - pub fn sqlite3_create_module( - db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - p: *const sqlite3_module, - pClientData: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_module_v2( - db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - p: *const sqlite3_module, - pClientData: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, + assert_eq!(::std::mem::size_of::() , 72usize); + assert_eq!(::std::mem::align_of::() , 8usize); } -#[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(pModule) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(nRef) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(zErrMsg) - ) - ); +impl Clone for sqlite3_index_info { + fn clone(&self) -> Self { *self } } #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy)] pub struct sqlite3_vtab_cursor { pub pVtab: *mut sqlite3_vtab, } #[test] fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab_cursor), - "::", - stringify!(pVtab) - ) - ); -} -extern "C" { - pub fn sqlite3_declare_vtab( - arg1: *mut sqlite3, - zSQL: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_overload_function( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + assert_eq!(::std::mem::size_of::() , 8usize); + assert_eq!(::std::mem::align_of::() , 8usize); +} +impl Clone for sqlite3_vtab_cursor { + fn clone(&self) -> Self { *self } } #[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob { - _unused: [u8; 0], +#[derive(Debug, Copy)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option ::std::os::raw::c_int>, + pub xConnect: ::std::option::Option ::std::os::raw::c_int>, + pub xBestIndex: ::std::option::Option ::std::os::raw::c_int>, + pub xDisconnect: ::std::option::Option ::std::os::raw::c_int>, + pub xDestroy: ::std::option::Option ::std::os::raw::c_int>, + pub xOpen: ::std::option::Option ::std::os::raw::c_int>, + pub xClose: ::std::option::Option ::std::os::raw::c_int>, + pub xFilter: ::std::option::Option ::std::os::raw::c_int>, + pub xNext: ::std::option::Option ::std::os::raw::c_int>, + pub xEof: ::std::option::Option ::std::os::raw::c_int>, + pub xColumn: ::std::option::Option ::std::os::raw::c_int>, + pub xRowid: ::std::option::Option ::std::os::raw::c_int>, + pub xUpdate: ::std::option::Option ::std::os::raw::c_int>, + pub xBegin: ::std::option::Option ::std::os::raw::c_int>, + pub xSync: ::std::option::Option ::std::os::raw::c_int>, + pub xCommit: ::std::option::Option ::std::os::raw::c_int>, + pub xRollback: ::std::option::Option ::std::os::raw::c_int>, + pub xFindFunction: ::std::option::Option, + ppArg: + *mut *mut ::std::os::raw::c_void) + -> ::std::os::raw::c_int>, + pub xRename: ::std::option::Option ::std::os::raw::c_int>, + pub xSavepoint: ::std::option::Option ::std::os::raw::c_int>, + pub xRelease: ::std::option::Option ::std::os::raw::c_int>, + pub xRollbackTo: ::std::option::Option ::std::os::raw::c_int>, +} +#[test] +fn bindgen_test_layout_sqlite3_module() { + assert_eq!(::std::mem::size_of::() , 184usize); + assert_eq!(::std::mem::align_of::() , 8usize); } +impl Clone for sqlite3_module { + fn clone(&self) -> Self { *self } +} +extern "C" { + pub fn sqlite3_create_module(db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + p: *const sqlite3_module, + pClientData: *mut ::std::os::raw::c_void) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_module_v2(db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + p: *const sqlite3_module, + pClientData: *mut ::std::os::raw::c_void, + xDestroy: + ::std::option::Option) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_declare_vtab(arg1: *mut sqlite3, + zSQL: *const ::std::os::raw::c_char) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_overload_function(arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_blob([u8; 0]); extern "C" { - pub fn sqlite3_blob_open( - arg1: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - zTable: *const ::std::os::raw::c_char, - zColumn: *const ::std::os::raw::c_char, - iRow: sqlite3_int64, - flags: ::std::os::raw::c_int, - ppBlob: *mut *mut sqlite3_blob, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_blob_open(arg1: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + zTable: *const ::std::os::raw::c_char, + zColumn: *const ::std::os::raw::c_char, + iRow: sqlite3_int64, + flags: ::std::os::raw::c_int, + ppBlob: *mut *mut sqlite3_blob) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_reopen( - arg1: *mut sqlite3_blob, - arg2: sqlite3_int64, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_blob_reopen(arg1: *mut sqlite3_blob, arg2: sqlite3_int64) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; + pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; + pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_read( - arg1: *mut sqlite3_blob, - Z: *mut ::std::os::raw::c_void, - N: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_blob_read(arg1: *mut sqlite3_blob, + Z: *mut ::std::os::raw::c_void, + N: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_write( - arg1: *mut sqlite3_blob, - z: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_blob_write(arg1: *mut sqlite3_blob, + z: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs; + pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) + -> *mut sqlite3_vfs; } extern "C" { - pub fn sqlite3_vfs_register( - arg1: *mut sqlite3_vfs, - makeDflt: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_vfs_register(arg1: *mut sqlite3_vfs, + makeDflt: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int; + pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex; + pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) + -> *mut sqlite3_mutex; } extern "C" { pub fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex); @@ -2961,872 +1931,367 @@ extern "C" { pub fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex); } extern "C" { - pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; + pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) + -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex); } #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy)] pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexNotheld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option *mut sqlite3_mutex>, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexNotheld: ::std::option::Option ::std::os::raw::c_int>, } #[test] fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexInit as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnd) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexAlloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexFree as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexFree) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexTry) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexLeave) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexHeld) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexNotheld) - ) - ); -} -extern "C" { - pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; + assert_eq!(::std::mem::size_of::() , 72usize); + assert_eq!(::std::mem::align_of::() , 8usize); +} +impl Clone for sqlite3_mutex_methods { + fn clone(&self) -> Self { *self } +} +extern "C" { + pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) + -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) + -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex; } extern "C" { - pub fn sqlite3_file_control( - arg1: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - op: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_file_control(arg1: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + op: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; + pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_status( - op: ::std::os::raw::c_int, - pCurrent: *mut ::std::os::raw::c_int, - pHighwater: *mut ::std::os::raw::c_int, - resetFlag: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_status(op: ::std::os::raw::c_int, + pCurrent: *mut ::std::os::raw::c_int, + pHighwater: *mut ::std::os::raw::c_int, + resetFlag: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_db_status( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - pCur: *mut ::std::os::raw::c_int, - pHiwtr: *mut ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_db_status(arg1: *mut sqlite3, op: ::std::os::raw::c_int, + pCur: *mut ::std::os::raw::c_int, + pHiwtr: *mut ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_stmt_status( - arg1: *mut sqlite3_stmt, - op: ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_stmt_status(arg1: *mut sqlite3_stmt, + op: ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache { - _unused: [u8; 0], -} +pub struct sqlite3_pcache([u8; 0]); #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy)] pub struct sqlite3_pcache_page { pub pBuf: *mut ::std::os::raw::c_void, pub pExtra: *mut ::std::os::raw::c_void, } #[test] fn bindgen_test_layout_sqlite3_pcache_page() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(sqlite3_pcache_page)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_page)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_page), - "::", - stringify!(pBuf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_page), - "::", - stringify!(pExtra) - ) - ); + assert_eq!(::std::mem::size_of::() , 16usize); + assert_eq!(::std::mem::align_of::() , 8usize); +} +impl Clone for sqlite3_pcache_page { + fn clone(&self) -> Self { *self } } #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy)] pub struct sqlite3_pcache_methods2 { pub iVersion: ::std::os::raw::c_int, pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - szExtra: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache_page, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut sqlite3_pcache_page, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut sqlite3_pcache_page, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, - pub xShrink: ::std::option::Option, + pub xInit: ::std::option::Option ::std::os::raw::c_int>, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option *mut sqlite3_pcache>, + pub xCachesize: ::std::option::Option, + pub xPagecount: ::std::option::Option ::std::os::raw::c_int>, + pub xFetch: ::std::option::Option *mut sqlite3_pcache_page>, + pub xUnpin: ::std::option::Option, + pub xRekey: ::std::option::Option, + pub xTruncate: ::std::option::Option, + pub xDestroy: ::std::option::Option, + pub xShrink: ::std::option::Option, } #[test] fn bindgen_test_layout_sqlite3_pcache_methods2() { - assert_eq!( - ::std::mem::size_of::(), - 104usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iVersion as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDestroy as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xShrink) - ) - ); + assert_eq!(::std::mem::size_of::() , 104usize); + assert_eq!(::std::mem::align_of::() , 8usize); +} +impl Clone for sqlite3_pcache_methods2 { + fn clone(&self) -> Self { *self } } #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy)] pub struct sqlite3_pcache_methods { pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, + pub xInit: ::std::option::Option ::std::os::raw::c_int>, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option *mut sqlite3_pcache>, + pub xCachesize: ::std::option::Option, + pub xPagecount: ::std::option::Option ::std::os::raw::c_int>, + pub xFetch: ::std::option::Option *mut ::std::os::raw::c_void>, + pub xUnpin: ::std::option::Option, + pub xRekey: ::std::option::Option, + pub xTruncate: ::std::option::Option, + pub xDestroy: ::std::option::Option, } #[test] fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!( - ::std::mem::size_of::(), - 88usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xDestroy) - ) - ); + assert_eq!(::std::mem::size_of::() , 88usize); + assert_eq!(::std::mem::align_of::() , 8usize); +} +impl Clone for sqlite3_pcache_methods { + fn clone(&self) -> Self { *self } } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_backup { - _unused: [u8; 0], -} +pub struct sqlite3_backup([u8; 0]); extern "C" { - pub fn sqlite3_backup_init( - pDest: *mut sqlite3, - zDestName: *const ::std::os::raw::c_char, - pSource: *mut sqlite3, - zSourceName: *const ::std::os::raw::c_char, - ) -> *mut sqlite3_backup; + pub fn sqlite3_backup_init(pDest: *mut sqlite3, + zDestName: *const ::std::os::raw::c_char, + pSource: *mut sqlite3, + zSourceName: *const ::std::os::raw::c_char) + -> *mut sqlite3_backup; } extern "C" { - pub fn sqlite3_backup_step( - p: *mut sqlite3_backup, - nPage: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_backup_step(p: *mut sqlite3_backup, + nPage: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_backup_finish(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; + pub fn sqlite3_backup_finish(p: *mut sqlite3_backup) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_backup_remaining(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; + pub fn sqlite3_backup_remaining(p: *mut sqlite3_backup) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_backup_pagecount(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; + pub fn sqlite3_backup_pagecount(p: *mut sqlite3_backup) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_unlock_notify( - pBlocked: *mut sqlite3, - xNotify: ::std::option::Option< - unsafe extern "C" fn( - apArg: *mut *mut ::std::os::raw::c_void, - nArg: ::std::os::raw::c_int, - ), - >, - pNotifyArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_unlock_notify(pBlocked: *mut sqlite3, + xNotify: + ::std::option::Option, + pNotifyArg: *mut ::std::os::raw::c_void) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_stricmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_stricmp(arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_strnicmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_strnicmp(arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_log( - iErrCode: ::std::os::raw::c_int, - zFormat: *const ::std::os::raw::c_char, - ... - ); + pub fn sqlite3_log(iErrCode: ::std::os::raw::c_int, + zFormat: *const ::std::os::raw::c_char, ...); } extern "C" { - pub fn sqlite3_wal_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void; + pub fn sqlite3_wal_hook(arg1: *mut sqlite3, + arg2: + ::std::option::Option + ::std::os::raw::c_int>, + arg3: *mut ::std::os::raw::c_void) + -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_wal_autocheckpoint( - db: *mut sqlite3, - N: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_wal_autocheckpoint(db: *mut sqlite3, + N: ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_wal_checkpoint( - db: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_wal_checkpoint(db: *mut sqlite3, + zDb: *const ::std::os::raw::c_char) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_wal_checkpoint_v2( - db: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - eMode: ::std::os::raw::c_int, - pnLog: *mut ::std::os::raw::c_int, - pnCkpt: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_wal_checkpoint_v2(db: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + eMode: ::std::os::raw::c_int, + pnLog: *mut ::std::os::raw::c_int, + pnCkpt: *mut ::std::os::raw::c_int) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_vtab_config( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int; + pub fn sqlite3_vtab_config(arg1: *mut sqlite3, + op: ::std::os::raw::c_int, ...) + -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_rtree_geometry_callback( - db: *mut sqlite3, - zGeom: *const ::std::os::raw::c_char, - xGeom: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_rtree_geometry, - n: ::std::os::raw::c_int, - a: *mut f64, - pRes: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pContext: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int; + pub fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) + -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy)] pub struct sqlite3_rtree_geometry { pub pContext: *mut ::std::os::raw::c_void, pub nParam: ::std::os::raw::c_int, pub aParam: *mut f64, pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, + pub xDelUser: ::std::option::Option, } #[test] fn bindgen_test_layout_sqlite3_rtree_geometry() { - assert_eq!( - ::std::mem::size_of::(), - 40usize, - concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pContext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(nParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(aParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pUser) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(xDelUser) - ) - ); + assert_eq!(::std::mem::size_of::() , 40usize); + assert_eq!(::std::mem::align_of::() , 8usize); +} +impl Clone for sqlite3_rtree_geometry { + fn clone(&self) -> Self { *self } +} +extern "C" { + pub fn sqlite3_rtree_geometry_callback(db: *mut sqlite3, + zGeom: + *const ::std::os::raw::c_char, + xGeom: + ::std::option::Option + ::std::os::raw::c_int>, + pContext: + *mut ::std::os::raw::c_void) + -> ::std::os::raw::c_int; } -pub type __builtin_va_list = [__va_list_tag; 1usize]; #[repr(C)] -#[derive(Debug, Copy, Clone)] +#[derive(Debug, Copy)] pub struct __va_list_tag { pub gp_offset: ::std::os::raw::c_uint, pub fp_offset: ::std::os::raw::c_uint, pub overflow_arg_area: *mut ::std::os::raw::c_void, pub reg_save_area: *mut ::std::os::raw::c_void, } -#[test] -fn bindgen_test_layout___va_list_tag() { - assert_eq!( - ::std::mem::size_of::<__va_list_tag>(), - 24usize, - concat!("Size of: ", stringify!(__va_list_tag)) - ); - assert_eq!( - ::std::mem::align_of::<__va_list_tag>(), - 8usize, - concat!("Alignment of ", stringify!(__va_list_tag)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(gp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(fp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(overflow_arg_area) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(reg_save_area) - ) - ); +impl Clone for __va_list_tag { + fn clone(&self) -> Self { *self } } +pub type __builtin_va_list = [__va_list_tag; 1usize]; + pub const SQLITE_DETERMINISTIC: i32 = 2048; From 2c6b6acb6a4878f16d4b52f79ba62512dcb87d22 Mon Sep 17 00:00:00 2001 From: gwenn Date: Tue, 11 Feb 2020 20:58:48 +0100 Subject: [PATCH 10/61] Ignore PATH change on Windows --- libsqlite3-sys/build.rs | 3 --- 1 file changed, 3 deletions(-) diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index 6d90429ae..039307875 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -341,9 +341,6 @@ mod build_loadable_extension { println!("cargo:rerun-if-env-changed={}_INCLUDE_DIR", env_prefix()); println!("cargo:rerun-if-env-changed={}_LIB_DIR", env_prefix()); println!("cargo:rerun-if-env-changed={}_STATIC", env_prefix()); - if cfg!(target_os = "windows") { - println!("cargo:rerun-if-env-changed=PATH"); - } if cfg!(all(feature = "vcpkg", target_env = "msvc")) { println!("cargo:rerun-if-env-changed=VCPKGRS_DYNAMIC"); } From 68bea40e806df992d11ff8d12480738fc34bb611 Mon Sep 17 00:00:00 2001 From: gwenn Date: Sat, 15 Feb 2020 12:34:42 +0100 Subject: [PATCH 11/61] Remove copyright header from build script --- libsqlite3-sys/build.rs | 22 ---------------------- 1 file changed, 22 deletions(-) diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index 039307875..5b3f5d990 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -1,25 +1,3 @@ -//***************************************************************************** -// Copyright (c) 2014 John Gallagher -// Copyright (c) 2019 Genomics plc -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE -//***************************************************************************** use std::env; use std::path::Path; From 325bfb6344fe94c595a34ab79cdfba6aa0e12d21 Mon Sep 17 00:00:00 2001 From: gwenn Date: Sat, 15 Feb 2020 12:36:02 +0100 Subject: [PATCH 12/61] Generate all three bindgen files --- libsqlite3-sys/upgrade.sh | 36 +++++++++++++++++++++++++----------- 1 file changed, 25 insertions(+), 11 deletions(-) diff --git a/libsqlite3-sys/upgrade.sh b/libsqlite3-sys/upgrade.sh index df35f8824..41af34b53 100755 --- a/libsqlite3-sys/upgrade.sh +++ b/libsqlite3-sys/upgrade.sh @@ -1,26 +1,40 @@ SCRIPT_DIR=$(cd "$(dirname "$_")" && pwd) echo $SCRIPT_DIR cd $SCRIPT_DIR + export SQLITE3_LIB_DIR=$SCRIPT_DIR/sqlite3 +export SQLITE3_INCLUDE_DIR=$SQLITE3_LIB_DIR # Download and extract amalgamation SQLITE=sqlite-amalgamation-3310000 -curl -O https://sqlite.org/2020/$SQLITE.zip -unzip -p $SQLITE.zip $SQLITE/sqlite3.c > $SQLITE3_LIB_DIR/sqlite3.c -unzip -p $SQLITE.zip $SQLITE/sqlite3.h > $SQLITE3_LIB_DIR/sqlite3.h -unzip -p $SQLITE.zip $SQLITE/sqlite3ext.h > $SQLITE3_LIB_DIR/sqlite3ext.h +curl -sSf -O https://sqlite.org/2020/$SQLITE.zip +unzip -p $SQLITE.zip $SQLITE/sqlite3.c >$SQLITE3_LIB_DIR/sqlite3.c +unzip -p $SQLITE.zip $SQLITE/sqlite3.h >$SQLITE3_LIB_DIR/sqlite3.h +unzip -p $SQLITE.zip $SQLITE/sqlite3ext.h >$SQLITE3_LIB_DIR/sqlite3ext.h rm -f $SQLITE.zip -# Regenerate bindgen file -rm -f $SQLITE3_LIB_DIR/bindgen_bundled_version.rs -export SQLITE3_INCLUDE_DIR=$SQLITE3_LIB_DIR +# Regenerate bindgen files cargo update -# Just to make sure there is only one bindgen.rs file in target dir -find $SCRIPT_DIR/../target -type f -name bindgen.rs -exec rm {} \; -cargo build --features "buildtime_bindgen" --no-default-features -find $SCRIPT_DIR/../target -type f -name bindgen.rs -exec cp {} $SQLITE3_LIB_DIR/bindgen_bundled_version.rs \; + +function generate_bindgen_binding() { + features=$1 + target_file=$2 + + rm -f $target_file + # Just to make sure there is only one bindgen.rs file in target dir + find $SCRIPT_DIR/../target -type f -name bindgen.rs -exec rm {} \; + cargo build --features "$features" --no-default-features + find $SCRIPT_DIR/../target -type f -name bindgen.rs -exec cp {} $target_file \; + # TODO rustfmt $target_file +} + +generate_bindgen_binding "buildtime_bindgen" $SQLITE3_LIB_DIR/bindgen_bundled_version.rs +generate_bindgen_binding "buildtime_bindgen,loadable_extension" $SQLITE3_LIB_DIR/bindgen_bundled_version-ext.rs +generate_bindgen_binding "buildtime_bindgen,loadable_extension_embedded" $SQLITE3_LIB_DIR/bindgen_bundled_version-ext-embed.rs + # Sanity check cd $SCRIPT_DIR/.. cargo update cargo test --features "backup blob chrono functions limits load_extension serde_json trace vtab bundled" +# TODO check loadable_extension / loadable_extension_embedded echo 'You should increment the version in libsqlite3-sys/Cargo.toml' From 2b170f0e1612484a06c0370d7838cc60ef47e841 Mon Sep 17 00:00:00 2001 From: gwenn Date: Sat, 15 Feb 2020 12:03:06 +0000 Subject: [PATCH 13/61] Generate new bindgen files for bundled version --- .../bindgen_bundled_version-ext-embed.rs | 11383 ++++++++++++++++ .../sqlite3/bindgen_bundled_version-ext.rs | 11381 +++++++++++++++ 2 files changed, 22764 insertions(+) create mode 100644 libsqlite3-sys/sqlite3/bindgen_bundled_version-ext-embed.rs create mode 100644 libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs diff --git a/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext-embed.rs b/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext-embed.rs new file mode 100644 index 000000000..fa164e120 --- /dev/null +++ b/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext-embed.rs @@ -0,0 +1,11383 @@ +/* automatically generated by rust-bindgen */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.31.0\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3031000; +pub const SQLITE_SOURCE_ID: &'static [u8; 85usize] = + b"2020-01-22 18:38:59 f6affdd41608946fcfcea914ece149038a8b25a62bbe719ed2561c649b86d824\0"; +pub const SQLITE_OK: i32 = 0; +pub const SQLITE_ERROR: i32 = 1; +pub const SQLITE_INTERNAL: i32 = 2; +pub const SQLITE_PERM: i32 = 3; +pub const SQLITE_ABORT: i32 = 4; +pub const SQLITE_BUSY: i32 = 5; +pub const SQLITE_LOCKED: i32 = 6; +pub const SQLITE_NOMEM: i32 = 7; +pub const SQLITE_READONLY: i32 = 8; +pub const SQLITE_INTERRUPT: i32 = 9; +pub const SQLITE_IOERR: i32 = 10; +pub const SQLITE_CORRUPT: i32 = 11; +pub const SQLITE_NOTFOUND: i32 = 12; +pub const SQLITE_FULL: i32 = 13; +pub const SQLITE_CANTOPEN: i32 = 14; +pub const SQLITE_PROTOCOL: i32 = 15; +pub const SQLITE_EMPTY: i32 = 16; +pub const SQLITE_SCHEMA: i32 = 17; +pub const SQLITE_TOOBIG: i32 = 18; +pub const SQLITE_CONSTRAINT: i32 = 19; +pub const SQLITE_MISMATCH: i32 = 20; +pub const SQLITE_MISUSE: i32 = 21; +pub const SQLITE_NOLFS: i32 = 22; +pub const SQLITE_AUTH: i32 = 23; +pub const SQLITE_FORMAT: i32 = 24; +pub const SQLITE_RANGE: i32 = 25; +pub const SQLITE_NOTADB: i32 = 26; +pub const SQLITE_NOTICE: i32 = 27; +pub const SQLITE_WARNING: i32 = 28; +pub const SQLITE_ROW: i32 = 100; +pub const SQLITE_DONE: i32 = 101; +pub const SQLITE_ERROR_MISSING_COLLSEQ: i32 = 257; +pub const SQLITE_ERROR_RETRY: i32 = 513; +pub const SQLITE_ERROR_SNAPSHOT: i32 = 769; +pub const SQLITE_IOERR_READ: i32 = 266; +pub const SQLITE_IOERR_SHORT_READ: i32 = 522; +pub const SQLITE_IOERR_WRITE: i32 = 778; +pub const SQLITE_IOERR_FSYNC: i32 = 1034; +pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; +pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; +pub const SQLITE_IOERR_FSTAT: i32 = 1802; +pub const SQLITE_IOERR_UNLOCK: i32 = 2058; +pub const SQLITE_IOERR_RDLOCK: i32 = 2314; +pub const SQLITE_IOERR_DELETE: i32 = 2570; +pub const SQLITE_IOERR_BLOCKED: i32 = 2826; +pub const SQLITE_IOERR_NOMEM: i32 = 3082; +pub const SQLITE_IOERR_ACCESS: i32 = 3338; +pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; +pub const SQLITE_IOERR_LOCK: i32 = 3850; +pub const SQLITE_IOERR_CLOSE: i32 = 4106; +pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; +pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; +pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; +pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; +pub const SQLITE_IOERR_SHMMAP: i32 = 5386; +pub const SQLITE_IOERR_SEEK: i32 = 5642; +pub const SQLITE_IOERR_DELETE_NOENT: i32 = 5898; +pub const SQLITE_IOERR_MMAP: i32 = 6154; +pub const SQLITE_IOERR_GETTEMPPATH: i32 = 6410; +pub const SQLITE_IOERR_CONVPATH: i32 = 6666; +pub const SQLITE_IOERR_VNODE: i32 = 6922; +pub const SQLITE_IOERR_AUTH: i32 = 7178; +pub const SQLITE_IOERR_BEGIN_ATOMIC: i32 = 7434; +pub const SQLITE_IOERR_COMMIT_ATOMIC: i32 = 7690; +pub const SQLITE_IOERR_ROLLBACK_ATOMIC: i32 = 7946; +pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; +pub const SQLITE_LOCKED_VTAB: i32 = 518; +pub const SQLITE_BUSY_RECOVERY: i32 = 261; +pub const SQLITE_BUSY_SNAPSHOT: i32 = 517; +pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; +pub const SQLITE_CANTOPEN_ISDIR: i32 = 526; +pub const SQLITE_CANTOPEN_FULLPATH: i32 = 782; +pub const SQLITE_CANTOPEN_CONVPATH: i32 = 1038; +pub const SQLITE_CANTOPEN_DIRTYWAL: i32 = 1294; +pub const SQLITE_CANTOPEN_SYMLINK: i32 = 1550; +pub const SQLITE_CORRUPT_VTAB: i32 = 267; +pub const SQLITE_CORRUPT_SEQUENCE: i32 = 523; +pub const SQLITE_READONLY_RECOVERY: i32 = 264; +pub const SQLITE_READONLY_CANTLOCK: i32 = 520; +pub const SQLITE_READONLY_ROLLBACK: i32 = 776; +pub const SQLITE_READONLY_DBMOVED: i32 = 1032; +pub const SQLITE_READONLY_CANTINIT: i32 = 1288; +pub const SQLITE_READONLY_DIRECTORY: i32 = 1544; +pub const SQLITE_ABORT_ROLLBACK: i32 = 516; +pub const SQLITE_CONSTRAINT_CHECK: i32 = 275; +pub const SQLITE_CONSTRAINT_COMMITHOOK: i32 = 531; +pub const SQLITE_CONSTRAINT_FOREIGNKEY: i32 = 787; +pub const SQLITE_CONSTRAINT_FUNCTION: i32 = 1043; +pub const SQLITE_CONSTRAINT_NOTNULL: i32 = 1299; +pub const SQLITE_CONSTRAINT_PRIMARYKEY: i32 = 1555; +pub const SQLITE_CONSTRAINT_TRIGGER: i32 = 1811; +pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067; +pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323; +pub const SQLITE_CONSTRAINT_ROWID: i32 = 2579; +pub const SQLITE_CONSTRAINT_PINNED: i32 = 2835; +pub const SQLITE_NOTICE_RECOVER_WAL: i32 = 283; +pub const SQLITE_NOTICE_RECOVER_ROLLBACK: i32 = 539; +pub const SQLITE_WARNING_AUTOINDEX: i32 = 284; +pub const SQLITE_AUTH_USER: i32 = 279; +pub const SQLITE_OK_LOAD_PERMANENTLY: i32 = 256; +pub const SQLITE_OK_SYMLINK: i32 = 512; +pub const SQLITE_OPEN_READONLY: i32 = 1; +pub const SQLITE_OPEN_READWRITE: i32 = 2; +pub const SQLITE_OPEN_CREATE: i32 = 4; +pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; +pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; +pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; +pub const SQLITE_OPEN_URI: i32 = 64; +pub const SQLITE_OPEN_MEMORY: i32 = 128; +pub const SQLITE_OPEN_MAIN_DB: i32 = 256; +pub const SQLITE_OPEN_TEMP_DB: i32 = 512; +pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; +pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; +pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; +pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; +pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; +pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; +pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; +pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; +pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; +pub const SQLITE_OPEN_WAL: i32 = 524288; +pub const SQLITE_OPEN_NOFOLLOW: i32 = 16777216; +pub const SQLITE_IOCAP_ATOMIC: i32 = 1; +pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; +pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; +pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; +pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; +pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; +pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; +pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; +pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; +pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; +pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; +pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; +pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE: i32 = 4096; +pub const SQLITE_IOCAP_IMMUTABLE: i32 = 8192; +pub const SQLITE_IOCAP_BATCH_ATOMIC: i32 = 16384; +pub const SQLITE_LOCK_NONE: i32 = 0; +pub const SQLITE_LOCK_SHARED: i32 = 1; +pub const SQLITE_LOCK_RESERVED: i32 = 2; +pub const SQLITE_LOCK_PENDING: i32 = 3; +pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; +pub const SQLITE_SYNC_NORMAL: i32 = 2; +pub const SQLITE_SYNC_FULL: i32 = 3; +pub const SQLITE_SYNC_DATAONLY: i32 = 16; +pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; +pub const SQLITE_FCNTL_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_FCNTL_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_FCNTL_LAST_ERRNO: i32 = 4; +pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; +pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; +pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; +pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; +pub const SQLITE_FCNTL_WIN32_AV_RETRY: i32 = 9; +pub const SQLITE_FCNTL_PERSIST_WAL: i32 = 10; +pub const SQLITE_FCNTL_OVERWRITE: i32 = 11; +pub const SQLITE_FCNTL_VFSNAME: i32 = 12; +pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE: i32 = 13; +pub const SQLITE_FCNTL_PRAGMA: i32 = 14; +pub const SQLITE_FCNTL_BUSYHANDLER: i32 = 15; +pub const SQLITE_FCNTL_TEMPFILENAME: i32 = 16; +pub const SQLITE_FCNTL_MMAP_SIZE: i32 = 18; +pub const SQLITE_FCNTL_TRACE: i32 = 19; +pub const SQLITE_FCNTL_HAS_MOVED: i32 = 20; +pub const SQLITE_FCNTL_SYNC: i32 = 21; +pub const SQLITE_FCNTL_COMMIT_PHASETWO: i32 = 22; +pub const SQLITE_FCNTL_WIN32_SET_HANDLE: i32 = 23; +pub const SQLITE_FCNTL_WAL_BLOCK: i32 = 24; +pub const SQLITE_FCNTL_ZIPVFS: i32 = 25; +pub const SQLITE_FCNTL_RBU: i32 = 26; +pub const SQLITE_FCNTL_VFS_POINTER: i32 = 27; +pub const SQLITE_FCNTL_JOURNAL_POINTER: i32 = 28; +pub const SQLITE_FCNTL_WIN32_GET_HANDLE: i32 = 29; +pub const SQLITE_FCNTL_PDB: i32 = 30; +pub const SQLITE_FCNTL_BEGIN_ATOMIC_WRITE: i32 = 31; +pub const SQLITE_FCNTL_COMMIT_ATOMIC_WRITE: i32 = 32; +pub const SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE: i32 = 33; +pub const SQLITE_FCNTL_LOCK_TIMEOUT: i32 = 34; +pub const SQLITE_FCNTL_DATA_VERSION: i32 = 35; +pub const SQLITE_FCNTL_SIZE_LIMIT: i32 = 36; +pub const SQLITE_FCNTL_CKPT_DONE: i32 = 37; +pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_LAST_ERRNO: i32 = 4; +pub const SQLITE_ACCESS_EXISTS: i32 = 0; +pub const SQLITE_ACCESS_READWRITE: i32 = 1; +pub const SQLITE_ACCESS_READ: i32 = 2; +pub const SQLITE_SHM_UNLOCK: i32 = 1; +pub const SQLITE_SHM_LOCK: i32 = 2; +pub const SQLITE_SHM_SHARED: i32 = 4; +pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; +pub const SQLITE_SHM_NLOCK: i32 = 8; +pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; +pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; +pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; +pub const SQLITE_CONFIG_MALLOC: i32 = 4; +pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; +pub const SQLITE_CONFIG_SCRATCH: i32 = 6; +pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; +pub const SQLITE_CONFIG_HEAP: i32 = 8; +pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; +pub const SQLITE_CONFIG_MUTEX: i32 = 10; +pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; +pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; +pub const SQLITE_CONFIG_PCACHE: i32 = 14; +pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; +pub const SQLITE_CONFIG_LOG: i32 = 16; +pub const SQLITE_CONFIG_URI: i32 = 17; +pub const SQLITE_CONFIG_PCACHE2: i32 = 18; +pub const SQLITE_CONFIG_GETPCACHE2: i32 = 19; +pub const SQLITE_CONFIG_COVERING_INDEX_SCAN: i32 = 20; +pub const SQLITE_CONFIG_SQLLOG: i32 = 21; +pub const SQLITE_CONFIG_MMAP_SIZE: i32 = 22; +pub const SQLITE_CONFIG_WIN32_HEAPSIZE: i32 = 23; +pub const SQLITE_CONFIG_PCACHE_HDRSZ: i32 = 24; +pub const SQLITE_CONFIG_PMASZ: i32 = 25; +pub const SQLITE_CONFIG_STMTJRNL_SPILL: i32 = 26; +pub const SQLITE_CONFIG_SMALL_MALLOC: i32 = 27; +pub const SQLITE_CONFIG_SORTERREF_SIZE: i32 = 28; +pub const SQLITE_CONFIG_MEMDB_MAXSIZE: i32 = 29; +pub const SQLITE_DBCONFIG_MAINDBNAME: i32 = 1000; +pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; +pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; +pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; +pub const SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: i32 = 1004; +pub const SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: i32 = 1005; +pub const SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE: i32 = 1006; +pub const SQLITE_DBCONFIG_ENABLE_QPSG: i32 = 1007; +pub const SQLITE_DBCONFIG_TRIGGER_EQP: i32 = 1008; +pub const SQLITE_DBCONFIG_RESET_DATABASE: i32 = 1009; +pub const SQLITE_DBCONFIG_DEFENSIVE: i32 = 1010; +pub const SQLITE_DBCONFIG_WRITABLE_SCHEMA: i32 = 1011; +pub const SQLITE_DBCONFIG_LEGACY_ALTER_TABLE: i32 = 1012; +pub const SQLITE_DBCONFIG_DQS_DML: i32 = 1013; +pub const SQLITE_DBCONFIG_DQS_DDL: i32 = 1014; +pub const SQLITE_DBCONFIG_ENABLE_VIEW: i32 = 1015; +pub const SQLITE_DBCONFIG_LEGACY_FILE_FORMAT: i32 = 1016; +pub const SQLITE_DBCONFIG_TRUSTED_SCHEMA: i32 = 1017; +pub const SQLITE_DBCONFIG_MAX: i32 = 1017; +pub const SQLITE_DENY: i32 = 1; +pub const SQLITE_IGNORE: i32 = 2; +pub const SQLITE_CREATE_INDEX: i32 = 1; +pub const SQLITE_CREATE_TABLE: i32 = 2; +pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; +pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; +pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; +pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; +pub const SQLITE_CREATE_TRIGGER: i32 = 7; +pub const SQLITE_CREATE_VIEW: i32 = 8; +pub const SQLITE_DELETE: i32 = 9; +pub const SQLITE_DROP_INDEX: i32 = 10; +pub const SQLITE_DROP_TABLE: i32 = 11; +pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; +pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; +pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; +pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; +pub const SQLITE_DROP_TRIGGER: i32 = 16; +pub const SQLITE_DROP_VIEW: i32 = 17; +pub const SQLITE_INSERT: i32 = 18; +pub const SQLITE_PRAGMA: i32 = 19; +pub const SQLITE_READ: i32 = 20; +pub const SQLITE_SELECT: i32 = 21; +pub const SQLITE_TRANSACTION: i32 = 22; +pub const SQLITE_UPDATE: i32 = 23; +pub const SQLITE_ATTACH: i32 = 24; +pub const SQLITE_DETACH: i32 = 25; +pub const SQLITE_ALTER_TABLE: i32 = 26; +pub const SQLITE_REINDEX: i32 = 27; +pub const SQLITE_ANALYZE: i32 = 28; +pub const SQLITE_CREATE_VTABLE: i32 = 29; +pub const SQLITE_DROP_VTABLE: i32 = 30; +pub const SQLITE_FUNCTION: i32 = 31; +pub const SQLITE_SAVEPOINT: i32 = 32; +pub const SQLITE_COPY: i32 = 0; +pub const SQLITE_RECURSIVE: i32 = 33; +pub const SQLITE_TRACE_STMT: i32 = 1; +pub const SQLITE_TRACE_PROFILE: i32 = 2; +pub const SQLITE_TRACE_ROW: i32 = 4; +pub const SQLITE_TRACE_CLOSE: i32 = 8; +pub const SQLITE_LIMIT_LENGTH: i32 = 0; +pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; +pub const SQLITE_LIMIT_COLUMN: i32 = 2; +pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; +pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; +pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; +pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; +pub const SQLITE_LIMIT_ATTACHED: i32 = 7; +pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; +pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; +pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; +pub const SQLITE_LIMIT_WORKER_THREADS: i32 = 11; +pub const SQLITE_PREPARE_PERSISTENT: i32 = 1; +pub const SQLITE_PREPARE_NORMALIZE: i32 = 2; +pub const SQLITE_PREPARE_NO_VTAB: i32 = 4; +pub const SQLITE_INTEGER: i32 = 1; +pub const SQLITE_FLOAT: i32 = 2; +pub const SQLITE_BLOB: i32 = 4; +pub const SQLITE_NULL: i32 = 5; +pub const SQLITE_TEXT: i32 = 3; +pub const SQLITE3_TEXT: i32 = 3; +pub const SQLITE_UTF8: i32 = 1; +pub const SQLITE_UTF16LE: i32 = 2; +pub const SQLITE_UTF16BE: i32 = 3; +pub const SQLITE_UTF16: i32 = 4; +pub const SQLITE_ANY: i32 = 5; +pub const SQLITE_UTF16_ALIGNED: i32 = 8; +pub const SQLITE_DETERMINISTIC: i32 = 2048; +pub const SQLITE_DIRECTONLY: i32 = 524288; +pub const SQLITE_SUBTYPE: i32 = 1048576; +pub const SQLITE_INNOCUOUS: i32 = 2097152; +pub const SQLITE_WIN32_DATA_DIRECTORY_TYPE: i32 = 1; +pub const SQLITE_WIN32_TEMP_DIRECTORY_TYPE: i32 = 2; +pub const SQLITE_INDEX_SCAN_UNIQUE: i32 = 1; +pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; +pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; +pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; +pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; +pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; +pub const SQLITE_INDEX_CONSTRAINT_LIKE: i32 = 65; +pub const SQLITE_INDEX_CONSTRAINT_GLOB: i32 = 66; +pub const SQLITE_INDEX_CONSTRAINT_REGEXP: i32 = 67; +pub const SQLITE_INDEX_CONSTRAINT_NE: i32 = 68; +pub const SQLITE_INDEX_CONSTRAINT_ISNOT: i32 = 69; +pub const SQLITE_INDEX_CONSTRAINT_ISNOTNULL: i32 = 70; +pub const SQLITE_INDEX_CONSTRAINT_ISNULL: i32 = 71; +pub const SQLITE_INDEX_CONSTRAINT_IS: i32 = 72; +pub const SQLITE_INDEX_CONSTRAINT_FUNCTION: i32 = 150; +pub const SQLITE_MUTEX_FAST: i32 = 0; +pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; +pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; +pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; +pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; +pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; +pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; +pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; +pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; +pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; +pub const SQLITE_MUTEX_STATIC_APP1: i32 = 8; +pub const SQLITE_MUTEX_STATIC_APP2: i32 = 9; +pub const SQLITE_MUTEX_STATIC_APP3: i32 = 10; +pub const SQLITE_MUTEX_STATIC_VFS1: i32 = 11; +pub const SQLITE_MUTEX_STATIC_VFS2: i32 = 12; +pub const SQLITE_MUTEX_STATIC_VFS3: i32 = 13; +pub const SQLITE_TESTCTRL_FIRST: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; +pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; +pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; +pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; +pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; +pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; +pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; +pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; +pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; +pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; +pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; +pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 17; +pub const SQLITE_TESTCTRL_INTERNAL_FUNCTIONS: i32 = 17; +pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 18; +pub const SQLITE_TESTCTRL_EXPLAIN_STMT: i32 = 19; +pub const SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD: i32 = 19; +pub const SQLITE_TESTCTRL_NEVER_CORRUPT: i32 = 20; +pub const SQLITE_TESTCTRL_VDBE_COVERAGE: i32 = 21; +pub const SQLITE_TESTCTRL_BYTEORDER: i32 = 22; +pub const SQLITE_TESTCTRL_ISINIT: i32 = 23; +pub const SQLITE_TESTCTRL_SORTER_MMAP: i32 = 24; +pub const SQLITE_TESTCTRL_IMPOSTER: i32 = 25; +pub const SQLITE_TESTCTRL_PARSER_COVERAGE: i32 = 26; +pub const SQLITE_TESTCTRL_RESULT_INTREAL: i32 = 27; +pub const SQLITE_TESTCTRL_PRNG_SEED: i32 = 28; +pub const SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS: i32 = 29; +pub const SQLITE_TESTCTRL_LAST: i32 = 29; +pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; +pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; +pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; +pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; +pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; +pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; +pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; +pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; +pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; +pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; +pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; +pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; +pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; +pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; +pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; +pub const SQLITE_DBSTATUS_CACHE_HIT: i32 = 7; +pub const SQLITE_DBSTATUS_CACHE_MISS: i32 = 8; +pub const SQLITE_DBSTATUS_CACHE_WRITE: i32 = 9; +pub const SQLITE_DBSTATUS_DEFERRED_FKS: i32 = 10; +pub const SQLITE_DBSTATUS_CACHE_USED_SHARED: i32 = 11; +pub const SQLITE_DBSTATUS_CACHE_SPILL: i32 = 12; +pub const SQLITE_DBSTATUS_MAX: i32 = 12; +pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; +pub const SQLITE_STMTSTATUS_SORT: i32 = 2; +pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; +pub const SQLITE_STMTSTATUS_VM_STEP: i32 = 4; +pub const SQLITE_STMTSTATUS_REPREPARE: i32 = 5; +pub const SQLITE_STMTSTATUS_RUN: i32 = 6; +pub const SQLITE_STMTSTATUS_MEMUSED: i32 = 99; +pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; +pub const SQLITE_CHECKPOINT_FULL: i32 = 1; +pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; +pub const SQLITE_CHECKPOINT_TRUNCATE: i32 = 3; +pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; +pub const SQLITE_VTAB_INNOCUOUS: i32 = 2; +pub const SQLITE_VTAB_DIRECTONLY: i32 = 3; +pub const SQLITE_ROLLBACK: i32 = 1; +pub const SQLITE_FAIL: i32 = 3; +pub const SQLITE_REPLACE: i32 = 5; +pub const SQLITE_SCANSTAT_NLOOP: i32 = 0; +pub const SQLITE_SCANSTAT_NVISIT: i32 = 1; +pub const SQLITE_SCANSTAT_EST: i32 = 2; +pub const SQLITE_SCANSTAT_NAME: i32 = 3; +pub const SQLITE_SCANSTAT_EXPLAIN: i32 = 4; +pub const SQLITE_SCANSTAT_SELECTID: i32 = 5; +pub const SQLITE_SERIALIZE_NOCOPY: i32 = 1; +pub const SQLITE_DESERIALIZE_FREEONCLOSE: i32 = 1; +pub const SQLITE_DESERIALIZE_RESIZEABLE: i32 = 2; +pub const SQLITE_DESERIALIZE_READONLY: i32 = 4; +pub const NOT_WITHIN: i32 = 0; +pub const PARTLY_WITHIN: i32 = 1; +pub const FULLY_WITHIN: i32 = 2; +pub const FTS5_TOKENIZE_QUERY: i32 = 1; +pub const FTS5_TOKENIZE_PREFIX: i32 = 2; +pub const FTS5_TOKENIZE_DOCUMENT: i32 = 4; +pub const FTS5_TOKENIZE_AUX: i32 = 8; +pub const FTS5_TOKEN_COLOCATED: i32 = 1; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; +extern "C" { + pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3 { + _unused: [u8; 0], +} +pub type sqlite_int64 = ::std::os::raw::c_longlong; +pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; +pub type sqlite3_int64 = sqlite_int64; +pub type sqlite3_uint64 = sqlite_uint64; +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_file { + pub pMethods: *const sqlite3_io_methods, +} +#[test] +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xShmMap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iPg: ::std::os::raw::c_int, + pgsz: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xShmLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + offset: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xShmBarrier: ::std::option::Option, + pub xShmUnmap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + deleteFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iOfst: sqlite3_int64, + iAmt: ::std::os::raw::c_int, + pp: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xUnfetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iOfst: sqlite3_int64, + p: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 152usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmMap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmBarrier) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmUnmap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnfetch as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnfetch) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +pub type sqlite3_syscall_ptr = ::std::option::Option; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vfs { + pub iVersion: ::std::os::raw::c_int, + pub szOsFile: ::std::os::raw::c_int, + pub mxPathname: ::std::os::raw::c_int, + pub pNext: *mut sqlite3_vfs, + pub zName: *const ::std::os::raw::c_char, + pub pAppData: *mut ::std::os::raw::c_void, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTimeInt64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xSetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: sqlite3_syscall_ptr, + ) -> ::std::os::raw::c_int, + >, + pub xGetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> sqlite3_syscall_ptr, + >, + pub xNextSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_vfs() { + assert_eq!( + ::std::mem::size_of::(), + 168usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTimeInt64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xNextSystemCall) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mem_methods { + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub pAppData: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_mem_methods() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_stmt { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_value { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_context { + _unused: [u8; 0], +} +pub type sqlite3_destructor_type = + ::std::option::Option; +extern "C" { + pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; +} +extern "C" { + pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSavepoint: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRelease: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRollbackTo: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xShadowName: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 192usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSavepoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRelease) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollbackTo) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShadowName as *const _ as usize }, + 184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xShadowName) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info { + pub nConstraint: ::std::os::raw::c_int, + pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, + pub nOrderBy: ::std::os::raw::c_int, + pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, + pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, + pub idxNum: ::std::os::raw::c_int, + pub idxStr: *mut ::std::os::raw::c_char, + pub needToFreeIdxStr: ::std::os::raw::c_int, + pub orderByConsumed: ::std::os::raw::c_int, + pub estimatedCost: f64, + pub estimatedRows: sqlite3_int64, + pub idxFlags: ::std::os::raw::c_int, + pub colUsed: sqlite3_uint64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint { + pub iColumn: ::std::os::raw::c_int, + pub op: ::std::os::raw::c_uchar, + pub usable: ::std::os::raw::c_uchar, + pub iTermOffset: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_orderby { + pub iColumn: ::std::os::raw::c_int, + pub desc: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint_usage { + pub argvIndex: ::std::os::raw::c_int, + pub omit: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); +} +#[test] +fn bindgen_test_layout_sqlite3_index_info() { + assert_eq!( + ::std::mem::size_of::(), + 96usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedRows as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedRows) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxFlags as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxFlags) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).colUsed as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(colUsed) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_blob { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex_methods { + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_mutex_methods() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_str { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_page { + pub pBuf: *mut ::std::os::raw::c_void, + pub pExtra: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_page() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pBuf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pExtra) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods2 { + pub iVersion: ::std::os::raw::c_int, + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + szExtra: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache_page, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, + pub xShrink: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods2() { + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iVersion as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDestroy as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShrink) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods { + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_backup { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct sqlite3_snapshot { + pub hidden: [::std::os::raw::c_uchar; 48usize], +} +#[test] +fn bindgen_test_layout_sqlite3_snapshot() { + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!("Size of: ", stringify!(sqlite3_snapshot)) + ); + assert_eq!( + ::std::mem::align_of::(), + 1usize, + concat!("Alignment of ", stringify!(sqlite3_snapshot)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).hidden as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_snapshot), + "::", + stringify!(hidden) + ) + ); +} +pub type sqlite3_rtree_dbl = f64; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_geometry { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut sqlite3_rtree_dbl, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_geometry() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(xDelUser) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_query_info { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut sqlite3_rtree_dbl, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, + pub aCoord: *mut sqlite3_rtree_dbl, + pub anQueue: *mut ::std::os::raw::c_uint, + pub nCoord: ::std::os::raw::c_int, + pub iLevel: ::std::os::raw::c_int, + pub mxLevel: ::std::os::raw::c_int, + pub iRowid: sqlite3_int64, + pub rParentScore: sqlite3_rtree_dbl, + pub eParentWithin: ::std::os::raw::c_int, + pub eWithin: ::std::os::raw::c_int, + pub rScore: sqlite3_rtree_dbl, + pub apSqlParam: *mut *mut sqlite3_value, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_query_info() { + assert_eq!( + ::std::mem::size_of::(), + 112usize, + concat!("Size of: ", stringify!(sqlite3_rtree_query_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_query_info)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).pContext as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDelUser as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(xDelUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aCoord as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(aCoord) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).anQueue as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(anQueue) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nCoord as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(nCoord) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iLevel as *const _ as usize }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(iLevel) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mxLevel as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(mxLevel) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iRowid as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(iRowid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rParentScore as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(rParentScore) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eParentWithin as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(eParentWithin) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eWithin as *const _ as usize + }, + 92usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(eWithin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).rScore as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(rScore) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).apSqlParam as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(apSqlParam) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5Context { + _unused: [u8; 0], +} +pub type fts5_extension_function = ::std::option::Option< + unsafe extern "C" fn( + pApi: *const Fts5ExtensionApi, + pFts: *mut Fts5Context, + pCtx: *mut sqlite3_context, + nVal: ::std::os::raw::c_int, + apVal: *mut *mut sqlite3_value, + ), +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5PhraseIter { + pub a: *const ::std::os::raw::c_uchar, + pub b: *const ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_Fts5PhraseIter() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Fts5PhraseIter)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Fts5PhraseIter)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).a as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Fts5PhraseIter), + "::", + stringify!(a) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).b as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Fts5PhraseIter), + "::", + stringify!(b) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5ExtensionApi { + pub iVersion: ::std::os::raw::c_int, + pub xUserData: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> *mut ::std::os::raw::c_void, + >, + pub xColumnCount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, + >, + pub xRowCount: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pnRow: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xColumnTotalSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pnToken: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTokenize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pText: *const ::std::os::raw::c_char, + nText: ::std::os::raw::c_int, + pCtx: *mut ::std::os::raw::c_void, + xToken: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + arg6: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseCount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, + >, + pub xPhraseSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xInstCount: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pnInst: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xInst: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iIdx: ::std::os::raw::c_int, + piPhrase: *mut ::std::os::raw::c_int, + piCol: *mut ::std::os::raw::c_int, + piOff: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: + ::std::option::Option sqlite3_int64>, + pub xColumnText: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pz: *mut *const ::std::os::raw::c_char, + pn: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xColumnSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pnToken: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xQueryPhrase: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + pUserData: *mut ::std::os::raw::c_void, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const Fts5ExtensionApi, + arg2: *mut Fts5Context, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub xSetAuxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pAux: *mut ::std::os::raw::c_void, + xDelete: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub xGetAuxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + bClear: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xPhraseFirst: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + arg2: *mut Fts5PhraseIter, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseNext: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + arg2: *mut Fts5PhraseIter, + piCol: *mut ::std::os::raw::c_int, + piOff: *mut ::std::os::raw::c_int, + ), + >, + pub xPhraseFirstColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + arg2: *mut Fts5PhraseIter, + arg3: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseNextColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + arg2: *mut Fts5PhraseIter, + piCol: *mut ::std::os::raw::c_int, + ), + >, +} +#[test] +fn bindgen_test_layout_Fts5ExtensionApi() { + assert_eq!( + ::std::mem::size_of::(), + 160usize, + concat!("Size of: ", stringify!(Fts5ExtensionApi)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Fts5ExtensionApi)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUserData as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xUserData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnCount as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowCount as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xRowCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xColumnTotalSize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnTotalSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xTokenize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseCount as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseSize as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInstCount as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xInstCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInst as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xInst) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnText as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnText) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnSize as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xQueryPhrase as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xQueryPhrase) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetAuxdata as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xSetAuxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetAuxdata as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xGetAuxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseFirst as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseFirst) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseNext as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseNext) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPhraseFirstColumn as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseFirstColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPhraseNextColumn as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseNextColumn) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5Tokenizer { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct fts5_tokenizer { + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + azArg: *mut *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ppOut: *mut *mut Fts5Tokenizer, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option, + pub xTokenize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Tokenizer, + pCtx: *mut ::std::os::raw::c_void, + flags: ::std::os::raw::c_int, + pText: *const ::std::os::raw::c_char, + nText: ::std::os::raw::c_int, + xToken: ::std::option::Option< + unsafe extern "C" fn( + pCtx: *mut ::std::os::raw::c_void, + tflags: ::std::os::raw::c_int, + pToken: *const ::std::os::raw::c_char, + nToken: ::std::os::raw::c_int, + iStart: ::std::os::raw::c_int, + iEnd: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_fts5_tokenizer() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(fts5_tokenizer)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(fts5_tokenizer)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xTokenize) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct fts5_api { + pub iVersion: ::std::os::raw::c_int, + pub xCreateTokenizer: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + pContext: *mut ::std::os::raw::c_void, + pTokenizer: *mut fts5_tokenizer, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub xFindTokenizer: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + ppContext: *mut *mut ::std::os::raw::c_void, + pTokenizer: *mut fts5_tokenizer, + ) -> ::std::os::raw::c_int, + >, + pub xCreateFunction: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + pContext: *mut ::std::os::raw::c_void, + xFunction: fts5_extension_function, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_fts5_api() { + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(fts5_api)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(fts5_api)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreateTokenizer as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xCreateTokenizer) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindTokenizer as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xFindTokenizer) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreateFunction as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xCreateFunction) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_api_routines { + pub aggregate_context: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub aggregate_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, + >, + pub bind_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_double: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int, + >, + pub bind_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, + ) -> ::std::os::raw::c_int, + >, + pub bind_null: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub bind_parameter_index: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub bind_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub busy_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub busy_timeout: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub changes: + ::std::option::Option ::std::os::raw::c_int>, + pub close: + ::std::option::Option ::std::os::raw::c_int>, + pub collation_needed: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub collation_needed16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub column_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_bytes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_bytes16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub column_database_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_database_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_decltype: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_decltype16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_double: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, + >, + pub column_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_int64: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, + >, + pub column_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_origin_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_origin_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_table_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_table_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar, + >, + pub column_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_type: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value, + >, + pub commit_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub complete: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub complete16: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub create_collation: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_collation16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_function16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_module: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub data_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub db_handle: + ::std::option::Option *mut sqlite3>, + pub declare_vtab: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub enable_shared_cache: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub errmsg: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, + >, + pub errmsg16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, + >, + pub exec: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub expired: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub finalize: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub free: ::std::option::Option, + pub free_table: + ::std::option::Option, + pub get_autocommit: + ::std::option::Option ::std::os::raw::c_int>, + pub get_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub get_table: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub global_recover: ::std::option::Option ::std::os::raw::c_int>, + pub interruptx: ::std::option::Option, + pub last_insert_rowid: + ::std::option::Option sqlite_int64>, + pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, + pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, + pub malloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub mprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub open16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub prepare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub profile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub progress_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ), + >, + pub realloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub result_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_double: + ::std::option::Option, + pub result_error: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_error16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_int64: + ::std::option::Option, + pub result_null: ::std::option::Option, + pub result_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16be: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16le: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_value: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), + >, + pub rollback_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub set_authorizer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub set_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, + ), + >, + pub xsnprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub step: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub table_column_metadata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub thread_cleanup: ::std::option::Option, + pub total_changes: + ::std::option::Option ::std::os::raw::c_int>, + pub trace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub transfer_bindings: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int, + >, + pub update_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub user_data: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, + >, + pub value_blob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_bytes16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_double: ::std::option::Option f64>, + pub value_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_int64: + ::std::option::Option sqlite_int64>, + pub value_numeric_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_text: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, + >, + pub value_text16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16be: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16le: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub vmprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub overload_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub prepare_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub clear_bindings: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub create_module_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_close: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int, + >, + pub blob_read: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_write: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub create_collation_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub file_control: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub memory_highwater: + ::std::option::Option sqlite3_int64>, + pub memory_used: ::std::option::Option sqlite3_int64>, + pub mutex_alloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub mutex_enter: ::std::option::Option, + pub mutex_free: ::std::option::Option, + pub mutex_leave: ::std::option::Option, + pub mutex_try: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub open_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub release_memory: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub result_error_nomem: ::std::option::Option, + pub result_error_toobig: + ::std::option::Option, + pub sleep: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub soft_heap_limit: ::std::option::Option, + pub vfs_find: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, + >, + pub vfs_register: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub vfs_unregister: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, + >, + pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, + pub result_zeroblob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_error_code: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub test_control: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, + >, + pub randomness: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), + >, + pub context_db_handle: + ::std::option::Option *mut sqlite3>, + pub extended_result_codes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub limit: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub next_stmt: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, + >, + pub sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, + >, + pub status: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub backup_finish: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_init: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, + ) -> *mut sqlite3_backup, + >, + pub backup_pagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_remaining: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_step: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub compileoption_get: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, + >, + pub compileoption_used: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub create_function_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub db_config: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int, + >, + pub db_mutex: + ::std::option::Option *mut sqlite3_mutex>, + pub db_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub extended_errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub log: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char, ...), + >, + pub soft_heap_limit64: + ::std::option::Option sqlite3_int64>, + pub sourceid: ::std::option::Option *const ::std::os::raw::c_char>, + pub stmt_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub strnicmp: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub unlock_notify: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub wal_autocheckpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub wal_checkpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub wal_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub blob_reopen: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob, arg2: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub vtab_config: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int, + >, + pub vtab_on_conflict: + ::std::option::Option ::std::os::raw::c_int>, + pub close_v2: + ::std::option::Option ::std::os::raw::c_int>, + pub db_filename: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, + pub db_readonly: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub db_release_memory: + ::std::option::Option ::std::os::raw::c_int>, + pub errstr: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, + >, + pub stmt_busy: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub stmt_readonly: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub stricmp: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub uri_boolean: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub uri_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64, + ) -> sqlite3_int64, + >, + pub uri_parameter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, + pub xvsnprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub wal_checkpoint_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub auto_extension: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_blob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + arg6: ::std::os::raw::c_uchar, + ) -> ::std::os::raw::c_int, + >, + pub cancel_auto_extension: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub load_extension: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub malloc64: ::std::option::Option< + unsafe extern "C" fn(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void, + >, + pub msize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64, + >, + pub realloc64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_uint64, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset_auto_extension: ::std::option::Option, + pub result_blob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + ), + >, + pub result_text64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + arg5: ::std::os::raw::c_uchar, + ), + >, + pub strglob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub value_dup: ::std::option::Option< + unsafe extern "C" fn(arg1: *const sqlite3_value) -> *mut sqlite3_value, + >, + pub value_free: ::std::option::Option, + pub result_zeroblob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: sqlite3_uint64, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_uint64, + ) -> ::std::os::raw::c_int, + >, + pub value_subtype: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint, + >, + pub result_subtype: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint), + >, + pub status64: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut sqlite3_int64, + arg3: *mut sqlite3_int64, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub strlike: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_uint, + ) -> ::std::os::raw::c_int, + >, + pub db_cacheflush: + ::std::option::Option ::std::os::raw::c_int>, + pub system_errno: + ::std::option::Option ::std::os::raw::c_int>, + pub trace_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_uint, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_uint, + arg2: *mut ::std::os::raw::c_void, + arg3: *mut ::std::os::raw::c_void, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub expanded_sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char, + >, + pub set_last_insert_rowid: + ::std::option::Option, + pub prepare_v3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_uint, + arg5: *mut *mut sqlite3_stmt, + arg6: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16_v3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_uint, + arg5: *mut *mut sqlite3_stmt, + arg6: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub bind_pointer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: *const ::std::os::raw::c_char, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub result_pointer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *mut ::std::os::raw::c_void, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::option::Option, + ), + >, + pub value_pointer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_value, + arg2: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub vtab_nochange: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, + >, + pub value_nochange: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub vtab_collation: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_index_info, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub keyword_count: ::std::option::Option ::std::os::raw::c_int>, + pub keyword_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut *const ::std::os::raw::c_char, + arg3: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub keyword_check: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub str_new: + ::std::option::Option *mut sqlite3_str>, + pub str_finish: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char, + >, + pub str_appendf: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_str, zFormat: *const ::std::os::raw::c_char, ...), + >, + pub str_vappendf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_str, + zFormat: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ), + >, + pub str_append: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_str, + zIn: *const ::std::os::raw::c_char, + N: ::std::os::raw::c_int, + ), + >, + pub str_appendall: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_str, zIn: *const ::std::os::raw::c_char), + >, + pub str_appendchar: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_str, + N: ::std::os::raw::c_int, + C: ::std::os::raw::c_char, + ), + >, + pub str_reset: ::std::option::Option, + pub str_errcode: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int, + >, + pub str_length: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int, + >, + pub str_value: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char, + >, + pub create_window_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xValue: ::std::option::Option, + xInv: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub normalized_sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, + >, + pub stmt_isexplain: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub value_frombind: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub drop_modules: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub hard_heap_limit64: + ::std::option::Option sqlite3_int64>, + pub uri_key: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub filename_database: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char, + >, + pub filename_journal: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char, + >, + pub filename_wal: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_api_routines() { + assert_eq!( + ::std::mem::size_of::(), + 1992usize, + concat!("Size of: ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_context as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_context) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_count as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_double as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_count as *const _ + as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_index as *const _ + as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_index) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_name as *const _ + as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text16 as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_handler as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_handler) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_timeout as *const _ as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_timeout) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed as *const _ as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_blob as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes as *const _ as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize + }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_count as *const _ as usize + }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name as *const _ + as usize + }, + 184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name16 as *const _ + as usize + }, + 192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype as *const _ as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize + }, + 208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_double as *const _ as usize + }, + 216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, + 224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_int64 as *const _ as usize + }, + 232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name as *const _ as usize + }, + 240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name16 as *const _ as usize + }, + 248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name as *const _ as usize + }, + 256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name16 as *const _ + as usize + }, + 264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name as *const _ as usize + }, + 272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name16 as *const _ + as usize + }, + 280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text as *const _ as usize + }, + 288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text16 as *const _ as usize + }, + 296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_type as *const _ as usize + }, + 304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_type) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_value as *const _ as usize + }, + 312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).commit_hook as *const _ as usize + }, + 320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(commit_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, + 328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, + 336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation as *const _ as usize + }, + 344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation16 as *const _ as usize + }, + 352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function as *const _ as usize + }, + 360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function16 as *const _ as usize + }, + 368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module as *const _ as usize + }, + 376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, + 384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(data_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, + 392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).declare_vtab as *const _ as usize + }, + 400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(declare_vtab) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).enable_shared_cache as *const _ + as usize + }, + 408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(enable_shared_cache) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, + 416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, + 424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, + 432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, + 440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(exec) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, + 448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(expired) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, + 456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(finalize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, + 464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, + 472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_autocommit as *const _ as usize + }, + 480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_autocommit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_auxdata as *const _ as usize + }, + 488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, + 496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).global_recover as *const _ as usize + }, + 504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(global_recover) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, + 512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(interruptx) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize + }, + 520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(last_insert_rowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, + 528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).libversion_number as *const _ as usize + }, + 536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion_number) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, + 544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, + 552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, + 560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, + 568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, + 576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, + 584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, + 592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(profile) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).progress_handler as *const _ as usize + }, + 600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(progress_handler) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, + 608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, + 616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob as *const _ as usize + }, + 624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_double as *const _ as usize + }, + 632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_double) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error as *const _ as usize + }, + 640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error16 as *const _ as usize + }, + 648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, + 656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_int64 as *const _ as usize + }, + 664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_null as *const _ as usize + }, + 672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text as *const _ as usize + }, + 680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16 as *const _ as usize + }, + 688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16be as *const _ as usize + }, + 696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16le as *const _ as usize + }, + 704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16le) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_value as *const _ as usize + }, + 712usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rollback_hook as *const _ as usize + }, + 720usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(rollback_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_authorizer as *const _ as usize + }, + 728usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_authorizer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_auxdata as *const _ as usize + }, + 736usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xsnprintf as *const _ as usize }, + 744usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xsnprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, + 752usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).table_column_metadata as *const _ + as usize + }, + 760usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(table_column_metadata) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize + }, + 768usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(thread_cleanup) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).total_changes as *const _ as usize + }, + 776usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(total_changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, + 784usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(trace) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize + }, + 792usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(transfer_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).update_hook as *const _ as usize + }, + 800usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(update_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, + 808usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(user_data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, + 816usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes as *const _ as usize + }, + 824usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize + }, + 832usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_double as *const _ as usize + }, + 840usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, + 848usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_int64 as *const _ as usize + }, + 856usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize + }, + 864usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_numeric_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, + 872usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16 as *const _ as usize + }, + 880usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16be as *const _ as usize + }, + 888usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16le as *const _ as usize + }, + 896usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16le) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, + 904usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, + 912usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vmprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).overload_function as *const _ as usize + }, + 920usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(overload_function) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, + 928usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize + }, + 936usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).clear_bindings as *const _ as usize + }, + 944usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(clear_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize + }, + 952usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize + }, + 960usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, + 968usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_bytes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, + 976usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_close) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, + 984usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, + 992usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_read) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, + 1000usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_write) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation_v2 as *const _ + as usize + }, + 1008usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).file_control as *const _ as usize + }, + 1016usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(file_control) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_highwater as *const _ as usize + }, + 1024usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_highwater) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_used as *const _ as usize + }, + 1032usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize + }, + 1040usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_alloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_enter as *const _ as usize + }, + 1048usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_enter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, + 1056usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_leave as *const _ as usize + }, + 1064usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_leave) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, + 1072usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_try) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, + 1080usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).release_memory as *const _ as usize + }, + 1088usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(release_memory) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize + }, + 1096usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_nomem) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_toobig as *const _ + as usize + }, + 1104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_toobig) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, + 1112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sleep) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize + }, + 1120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, + 1128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_find) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_register as *const _ as usize + }, + 1136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_register) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize + }, + 1144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_unregister) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize + }, + 1152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xthreadsafe) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize + }, + 1160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_code as *const _ as usize + }, + 1168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_code) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).test_control as *const _ as usize + }, + 1176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(test_control) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, + 1184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(randomness) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).context_db_handle as *const _ as usize + }, + 1192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(context_db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_result_codes as *const _ + as usize + }, + 1200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_result_codes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, + 1208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, + 1216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(next_stmt) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, + 1224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sql) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, + 1232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_finish as *const _ as usize + }, + 1240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_finish) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_init as *const _ as usize + }, + 1248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_init) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_pagecount as *const _ as usize + }, + 1256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_pagecount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_remaining as *const _ as usize + }, + 1264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_remaining) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_step as *const _ as usize + }, + 1272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_get as *const _ as usize + }, + 1280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_get) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_used as *const _ as usize + }, + 1288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function_v2 as *const _ as usize + }, + 1296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function_v2) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_config as *const _ as usize }, + 1304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_config) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_mutex as *const _ as usize }, + 1312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_mutex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_status as *const _ as usize }, + 1320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_errcode as *const _ as usize + }, + 1328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).log as *const _ as usize }, + 1336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(log) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit64 as *const _ as usize + }, + 1344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sourceid as *const _ as usize }, + 1352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sourceid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stmt_status as *const _ as usize + }, + 1360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_status) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strnicmp as *const _ as usize }, + 1368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strnicmp) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).unlock_notify as *const _ as usize + }, + 1376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(unlock_notify) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_autocheckpoint as *const _ as usize + }, + 1384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_autocheckpoint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_checkpoint as *const _ as usize + }, + 1392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_checkpoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).wal_hook as *const _ as usize }, + 1400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).blob_reopen as *const _ as usize + }, + 1408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_reopen) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_config as *const _ as usize + }, + 1416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_config) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_on_conflict as *const _ as usize + }, + 1424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_on_conflict) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close_v2 as *const _ as usize }, + 1432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_filename as *const _ as usize + }, + 1440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_filename) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_readonly as *const _ as usize + }, + 1448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_readonly) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_release_memory as *const _ as usize + }, + 1456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_release_memory) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errstr as *const _ as usize }, + 1464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errstr) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).stmt_busy as *const _ as usize }, + 1472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_busy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stmt_readonly as *const _ as usize + }, + 1480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_readonly) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).stricmp as *const _ as usize }, + 1488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stricmp) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).uri_boolean as *const _ as usize + }, + 1496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_boolean) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).uri_int64 as *const _ as usize }, + 1504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).uri_parameter as *const _ as usize + }, + 1512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_parameter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xvsnprintf as *const _ as usize }, + 1520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xvsnprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_checkpoint_v2 as *const _ as usize + }, + 1528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_checkpoint_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).auto_extension as *const _ as usize + }, + 1536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(auto_extension) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_blob64 as *const _ as usize + }, + 1544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text64 as *const _ as usize + }, + 1552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).cancel_auto_extension as *const _ + as usize + }, + 1560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(cancel_auto_extension) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).load_extension as *const _ as usize + }, + 1568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(load_extension) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc64 as *const _ as usize }, + 1576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).msize as *const _ as usize }, + 1584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(msize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc64 as *const _ as usize }, + 1592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).reset_auto_extension as *const _ + as usize + }, + 1600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset_auto_extension) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob64 as *const _ as usize + }, + 1608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text64 as *const _ as usize + }, + 1616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strglob as *const _ as usize }, + 1624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strglob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_dup as *const _ as usize }, + 1632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_dup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_free as *const _ as usize }, + 1640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob64 as *const _ as usize + }, + 1648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob64 as *const _ as usize + }, + 1656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_subtype as *const _ as usize + }, + 1664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_subtype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_subtype as *const _ as usize + }, + 1672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_subtype) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status64 as *const _ as usize }, + 1680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strlike as *const _ as usize }, + 1688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strlike) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_cacheflush as *const _ as usize + }, + 1696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_cacheflush) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).system_errno as *const _ as usize + }, + 1704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(system_errno) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).trace_v2 as *const _ as usize }, + 1712usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(trace_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).expanded_sql as *const _ as usize + }, + 1720usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(expanded_sql) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_last_insert_rowid as *const _ + as usize + }, + 1728usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_last_insert_rowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare_v3 as *const _ as usize }, + 1736usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare_v3) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).prepare16_v3 as *const _ as usize + }, + 1744usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16_v3) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_pointer as *const _ as usize + }, + 1752usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_pointer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_pointer as *const _ as usize + }, + 1760usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_pointer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_pointer as *const _ as usize + }, + 1768usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_pointer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_nochange as *const _ as usize + }, + 1776usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_nochange) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_nochange as *const _ as usize + }, + 1784usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_nochange) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_collation as *const _ as usize + }, + 1792usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_collation) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).keyword_count as *const _ as usize + }, + 1800usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(keyword_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).keyword_name as *const _ as usize + }, + 1808usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(keyword_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).keyword_check as *const _ as usize + }, + 1816usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(keyword_check) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).str_new as *const _ as usize }, + 1824usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_new) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).str_finish as *const _ as usize }, + 1832usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_finish) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).str_appendf as *const _ as usize + }, + 1840usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_appendf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).str_vappendf as *const _ as usize + }, + 1848usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_vappendf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).str_append as *const _ as usize }, + 1856usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_append) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).str_appendall as *const _ as usize + }, + 1864usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_appendall) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).str_appendchar as *const _ as usize + }, + 1872usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_appendchar) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).str_reset as *const _ as usize }, + 1880usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_reset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).str_errcode as *const _ as usize + }, + 1888usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).str_length as *const _ as usize }, + 1896usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_length) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).str_value as *const _ as usize }, + 1904usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_window_function as *const _ + as usize + }, + 1912usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_window_function) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).normalized_sql as *const _ as usize + }, + 1920usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(normalized_sql) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stmt_isexplain as *const _ as usize + }, + 1928usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_isexplain) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_frombind as *const _ as usize + }, + 1936usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_frombind) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).drop_modules as *const _ as usize + }, + 1944usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(drop_modules) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).hard_heap_limit64 as *const _ as usize + }, + 1952usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(hard_heap_limit64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).uri_key as *const _ as usize }, + 1960usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_key) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).filename_database as *const _ as usize + }, + 1968usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(filename_database) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).filename_journal as *const _ as usize + }, + 1976usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(filename_journal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).filename_wal as *const _ as usize + }, + 1984usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(filename_wal) + ) + ); +} +pub type sqlite3_loadext_entry = ::std::option::Option< + unsafe extern "C" fn( + db: *mut sqlite3, + pzErrMsg: *mut *mut ::std::os::raw::c_char, + pThunk: *const sqlite3_api_routines, + ) -> ::std::os::raw::c_int, +>; +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} + +// bindings were built with loadable_extension_embedded: +// define sqlite3_api as an extern since this code will be embedded +// within a loadable extension that defines and exports this itself +extern "C" { + #[no_mangle] + pub static mut sqlite3_api: *mut sqlite3_api_routines; +} + +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) + +pub unsafe fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_context.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_context", + " function" + )))(arg1, nBytes) +} + +pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_double", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_null", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_index.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_index", + " function" + )))(arg1, zName) +} + +pub unsafe fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_value", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_handler", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_timeout.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_timeout", + " function" + )))(arg1, ms) +} + +pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_blob", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype", + " function" + )))(arg1, i) +} + +pub unsafe fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_double", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int64", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_type", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_value", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).commit_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "commit_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete16", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_create_collation( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_collation16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_function( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_function16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function16", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_module( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).data_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "data_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).declare_vtab.expect(stringify!( + "sqlite3_api contains null pointer for ", + "declare_vtab", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).enable_shared_cache.expect(stringify!( + "sqlite3_api contains null pointer for ", + "enable_shared_cache", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errcode", + " function" + )))(db) +} + +pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_exec( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).exec.expect(stringify!( + "sqlite3_api contains null pointer for ", + "exec", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).expired.expect(stringify!( + "sqlite3_api contains null pointer for ", + "expired", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).finalize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "finalize", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free_table", + " function" + )))(result) +} + +pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_autocommit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_autocommit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_auxdata", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_get_table( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_table", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).global_recover.expect(stringify!( + "sqlite3_api contains null pointer for ", + "global_recover", + " function" + )))() +} + +pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).interruptx.expect(stringify!( + "sqlite3_api contains null pointer for ", + "interruptx", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).last_insert_rowid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "last_insert_rowid", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion", + " function" + )))() +} + +pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion_number.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion_number", + " function" + )))() +} + +pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mprintf( + arg1: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mprintf", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_open( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_open16( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_prepare( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_profile( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).profile.expect(stringify!( + "sqlite3_api contains null pointer for ", + "profile", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).progress_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "progress_handler", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_double", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_null", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16be", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16le", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_value", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).rollback_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "rollback_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_authorizer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_authorizer", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_auxdata", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_xsnprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xsnprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xsnprintf", + " function" + )))(arg1, arg2, arg3, vararg1) +} + +pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "step", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_table_column_metadata( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).table_column_metadata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "table_column_metadata", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) +} + +pub unsafe fn sqlite3_thread_cleanup() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).thread_cleanup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "thread_cleanup", + " function" + )))() +} + +pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).total_changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "total_changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).trace.expect(stringify!( + "sqlite3_api contains null pointer for ", + "trace", + " function" + )))(arg1, xTrace, arg2) +} + +pub unsafe fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).transfer_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "transfer_bindings", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).update_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "update_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).user_data.expect(stringify!( + "sqlite3_api contains null pointer for ", + "user_data", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_blob", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_double", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_numeric_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_numeric_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16be", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16le", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vmprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vmprintf", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).overload_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "overload_function", + " function" + )))(arg1, zFuncName, nArg) +} + +pub unsafe fn sqlite3_prepare_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).clear_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "clear_bindings", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_module_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module_v2", + " function" + )))(arg1, arg2, arg3, arg4, xDestroy) +} + +pub unsafe fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_open( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_open", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) +} + +pub unsafe fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_read.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_read", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_write.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_write", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_file_control( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).file_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "file_control", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_highwater.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_highwater", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_used", + " function" + )))() +} + +pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_alloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_alloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_enter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_enter", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_leave.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_leave", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_try.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_try", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_open_v2( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open_v2", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_nomem.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_nomem", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_toobig.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_toobig", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sleep.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sleep", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_find.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_find", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_register.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_register", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_unregister.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_unregister", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xthreadsafe.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xthreadsafe", + " function" + )))() +} + +pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_code.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_code", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_test_control( + arg1: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).test_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "test_control", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).randomness.expect(stringify!( + "sqlite3_api contains null pointer for ", + "randomness", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).context_db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "context_db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_result_codes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_result_codes", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_limit( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "limit", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).next_stmt.expect(stringify!( + "sqlite3_api contains null pointer for ", + "next_stmt", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_status( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_finish.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_finish", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_init( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, +) -> *mut sqlite3_backup { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_init.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_init", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_pagecount.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_pagecount", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_remaining.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_remaining", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_step( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_step", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_compileoption_get( + arg1: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_get.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_get", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_compileoption_used( + arg1: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_used", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_function_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal, xDestroy) +} + +pub unsafe fn sqlite3_db_config( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, + vararg2: &mut i32, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_config", + " function" + )))(arg1, arg2, vararg1, vararg2) +} + +pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_mutex.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_mutex", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_db_status( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_status", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_errcode", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_log( + arg1: ::std::os::raw::c_int, + arg2: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).log.expect(stringify!( + "sqlite3_api contains null pointer for ", + "log", + " function" + )))(arg1, arg2, vararg1) +} + +pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sourceid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sourceid", + " function" + )))() +} + +pub unsafe fn sqlite3_stmt_status( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_status", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_strnicmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strnicmp.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strnicmp", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_unlock_notify( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int), + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).unlock_notify.expect(stringify!( + "sqlite3_api contains null pointer for ", + "unlock_notify", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_wal_autocheckpoint( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_autocheckpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_checkpoint( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_checkpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_checkpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_reopen( + arg1: *mut sqlite3_blob, + arg2: sqlite3_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_reopen.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_reopen", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vtab_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_config", + " function" + )))(arg1, op, vararg1) +} + +pub unsafe fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_on_conflict.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_on_conflict", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close_v2", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_db_filename( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_filename.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_filename", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_db_readonly( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_readonly.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_readonly", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errstr.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errstr", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_busy.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_busy", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stmt_readonly(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_readonly.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_readonly", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stricmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stricmp.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stricmp", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_uri_boolean( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_boolean.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_boolean", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_uri_int64( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64, +) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_uri_parameter( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_parameter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_parameter", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_xvsnprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xvsnprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xvsnprintf", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_wal_checkpoint_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_checkpoint_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_checkpoint_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_auto_extension( + arg1: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).auto_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "auto_extension", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob64", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_text64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + arg6: ::std::os::raw::c_uchar, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text64", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_cancel_auto_extension( + arg1: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).cancel_auto_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "cancel_auto_extension", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_load_extension( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).load_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "load_extension", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_malloc64(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_msize(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).msize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "msize", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_realloc64( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_uint64, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset_auto_extension() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset_auto_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset_auto_extension", + " function" + )))() +} + +pub unsafe fn sqlite3_result_blob64( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob64", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text64( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + arg5: ::std::os::raw::c_uchar, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text64", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_strglob( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strglob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strglob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_value_dup(arg1: *const sqlite3_value) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_dup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_dup", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_free(arg1: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_zeroblob64( + arg1: *mut sqlite3_context, + arg2: sqlite3_uint64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_zeroblob64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_uint64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_value_subtype(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_subtype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_subtype", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_subtype(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_subtype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_subtype", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_status64( + arg1: ::std::os::raw::c_int, + arg2: *mut sqlite3_int64, + arg3: *mut sqlite3_int64, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status64", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_strlike( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_uint, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strlike.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strlike", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_db_cacheflush(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_cacheflush.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_cacheflush", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_system_errno(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).system_errno.expect(stringify!( + "sqlite3_api contains null pointer for ", + "system_errno", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_trace_v2( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_uint, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_uint, + arg2: *mut ::std::os::raw::c_void, + arg3: *mut ::std::os::raw::c_void, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).trace_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "trace_v2", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_expanded_sql(arg1: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).expanded_sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "expanded_sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_set_last_insert_rowid(arg1: *mut sqlite3, arg2: sqlite3_int64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_last_insert_rowid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_last_insert_rowid", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_prepare_v3( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_uint, + arg5: *mut *mut sqlite3_stmt, + arg6: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare_v3.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare_v3", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_prepare16_v3( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_uint, + arg5: *mut *mut sqlite3_stmt, + arg6: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16_v3.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16_v3", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_bind_pointer( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: *const ::std::os::raw::c_char, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_pointer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_pointer", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_result_pointer( + arg1: *mut sqlite3_context, + arg2: *mut ::std::os::raw::c_void, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_pointer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_pointer", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_value_pointer( + arg1: *mut sqlite3_value, + arg2: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_pointer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_pointer", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vtab_nochange(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_nochange.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_nochange", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_nochange(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_nochange.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_nochange", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vtab_collation( + arg1: *mut sqlite3_index_info, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_collation.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_collation", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_keyword_count() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).keyword_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "keyword_count", + " function" + )))() +} + +pub unsafe fn sqlite3_keyword_name( + arg1: ::std::os::raw::c_int, + arg2: *mut *const ::std::os::raw::c_char, + arg3: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).keyword_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "keyword_name", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_keyword_check( + arg1: *const ::std::os::raw::c_char, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).keyword_check.expect(stringify!( + "sqlite3_api contains null pointer for ", + "keyword_check", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_str_new(arg1: *mut sqlite3) -> *mut sqlite3_str { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_new.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_new", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_str_finish(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_finish.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_finish", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_str_appendf( + arg1: *mut sqlite3_str, + zFormat: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_appendf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_appendf", + " function" + )))(arg1, zFormat, vararg1) +} + +pub unsafe fn sqlite3_str_vappendf( + arg1: *mut sqlite3_str, + zFormat: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_vappendf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_vappendf", + " function" + )))(arg1, zFormat, arg2) +} + +pub unsafe fn sqlite3_str_append( + arg1: *mut sqlite3_str, + zIn: *const ::std::os::raw::c_char, + N: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_append.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_append", + " function" + )))(arg1, zIn, N) +} + +pub unsafe fn sqlite3_str_appendall(arg1: *mut sqlite3_str, zIn: *const ::std::os::raw::c_char) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_appendall.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_appendall", + " function" + )))(arg1, zIn) +} + +pub unsafe fn sqlite3_str_appendchar( + arg1: *mut sqlite3_str, + N: ::std::os::raw::c_int, + C: ::std::os::raw::c_char, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_appendchar.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_appendchar", + " function" + )))(arg1, N, C) +} + +pub unsafe fn sqlite3_str_reset(arg1: *mut sqlite3_str) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_reset.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_reset", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_str_errcode(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_errcode", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_str_length(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_length.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_length", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_str_value(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_value", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_window_function( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xValue: ::std::option::Option, + xInv: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_window_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_window_function", + " function" + )))( + arg1, arg2, arg3, arg4, arg5, xStep, xFinal, xValue, xInv, xDestroy, + ) +} + +pub unsafe fn sqlite3_normalized_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).normalized_sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "normalized_sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stmt_isexplain(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_isexplain.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_isexplain", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_frombind(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_frombind.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_frombind", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_drop_modules( + arg1: *mut sqlite3, + arg2: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).drop_modules.expect(stringify!( + "sqlite3_api contains null pointer for ", + "drop_modules", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_hard_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).hard_heap_limit64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "hard_heap_limit64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_uri_key( + arg1: *const ::std::os::raw::c_char, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_key.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_key", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_filename_database( + arg1: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).filename_database.expect(stringify!( + "sqlite3_api contains null pointer for ", + "filename_database", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_filename_journal( + arg1: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).filename_journal.expect(stringify!( + "sqlite3_api contains null pointer for ", + "filename_journal", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_filename_wal( + arg1: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).filename_wal.expect(stringify!( + "sqlite3_api contains null pointer for ", + "filename_wal", + " function" + )))(arg1) +} diff --git a/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs b/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs new file mode 100644 index 000000000..99b82f013 --- /dev/null +++ b/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs @@ -0,0 +1,11381 @@ +/* automatically generated by rust-bindgen */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.31.0\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3031000; +pub const SQLITE_SOURCE_ID: &'static [u8; 85usize] = + b"2020-01-22 18:38:59 f6affdd41608946fcfcea914ece149038a8b25a62bbe719ed2561c649b86d824\0"; +pub const SQLITE_OK: i32 = 0; +pub const SQLITE_ERROR: i32 = 1; +pub const SQLITE_INTERNAL: i32 = 2; +pub const SQLITE_PERM: i32 = 3; +pub const SQLITE_ABORT: i32 = 4; +pub const SQLITE_BUSY: i32 = 5; +pub const SQLITE_LOCKED: i32 = 6; +pub const SQLITE_NOMEM: i32 = 7; +pub const SQLITE_READONLY: i32 = 8; +pub const SQLITE_INTERRUPT: i32 = 9; +pub const SQLITE_IOERR: i32 = 10; +pub const SQLITE_CORRUPT: i32 = 11; +pub const SQLITE_NOTFOUND: i32 = 12; +pub const SQLITE_FULL: i32 = 13; +pub const SQLITE_CANTOPEN: i32 = 14; +pub const SQLITE_PROTOCOL: i32 = 15; +pub const SQLITE_EMPTY: i32 = 16; +pub const SQLITE_SCHEMA: i32 = 17; +pub const SQLITE_TOOBIG: i32 = 18; +pub const SQLITE_CONSTRAINT: i32 = 19; +pub const SQLITE_MISMATCH: i32 = 20; +pub const SQLITE_MISUSE: i32 = 21; +pub const SQLITE_NOLFS: i32 = 22; +pub const SQLITE_AUTH: i32 = 23; +pub const SQLITE_FORMAT: i32 = 24; +pub const SQLITE_RANGE: i32 = 25; +pub const SQLITE_NOTADB: i32 = 26; +pub const SQLITE_NOTICE: i32 = 27; +pub const SQLITE_WARNING: i32 = 28; +pub const SQLITE_ROW: i32 = 100; +pub const SQLITE_DONE: i32 = 101; +pub const SQLITE_ERROR_MISSING_COLLSEQ: i32 = 257; +pub const SQLITE_ERROR_RETRY: i32 = 513; +pub const SQLITE_ERROR_SNAPSHOT: i32 = 769; +pub const SQLITE_IOERR_READ: i32 = 266; +pub const SQLITE_IOERR_SHORT_READ: i32 = 522; +pub const SQLITE_IOERR_WRITE: i32 = 778; +pub const SQLITE_IOERR_FSYNC: i32 = 1034; +pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; +pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; +pub const SQLITE_IOERR_FSTAT: i32 = 1802; +pub const SQLITE_IOERR_UNLOCK: i32 = 2058; +pub const SQLITE_IOERR_RDLOCK: i32 = 2314; +pub const SQLITE_IOERR_DELETE: i32 = 2570; +pub const SQLITE_IOERR_BLOCKED: i32 = 2826; +pub const SQLITE_IOERR_NOMEM: i32 = 3082; +pub const SQLITE_IOERR_ACCESS: i32 = 3338; +pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; +pub const SQLITE_IOERR_LOCK: i32 = 3850; +pub const SQLITE_IOERR_CLOSE: i32 = 4106; +pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; +pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; +pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; +pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; +pub const SQLITE_IOERR_SHMMAP: i32 = 5386; +pub const SQLITE_IOERR_SEEK: i32 = 5642; +pub const SQLITE_IOERR_DELETE_NOENT: i32 = 5898; +pub const SQLITE_IOERR_MMAP: i32 = 6154; +pub const SQLITE_IOERR_GETTEMPPATH: i32 = 6410; +pub const SQLITE_IOERR_CONVPATH: i32 = 6666; +pub const SQLITE_IOERR_VNODE: i32 = 6922; +pub const SQLITE_IOERR_AUTH: i32 = 7178; +pub const SQLITE_IOERR_BEGIN_ATOMIC: i32 = 7434; +pub const SQLITE_IOERR_COMMIT_ATOMIC: i32 = 7690; +pub const SQLITE_IOERR_ROLLBACK_ATOMIC: i32 = 7946; +pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; +pub const SQLITE_LOCKED_VTAB: i32 = 518; +pub const SQLITE_BUSY_RECOVERY: i32 = 261; +pub const SQLITE_BUSY_SNAPSHOT: i32 = 517; +pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; +pub const SQLITE_CANTOPEN_ISDIR: i32 = 526; +pub const SQLITE_CANTOPEN_FULLPATH: i32 = 782; +pub const SQLITE_CANTOPEN_CONVPATH: i32 = 1038; +pub const SQLITE_CANTOPEN_DIRTYWAL: i32 = 1294; +pub const SQLITE_CANTOPEN_SYMLINK: i32 = 1550; +pub const SQLITE_CORRUPT_VTAB: i32 = 267; +pub const SQLITE_CORRUPT_SEQUENCE: i32 = 523; +pub const SQLITE_READONLY_RECOVERY: i32 = 264; +pub const SQLITE_READONLY_CANTLOCK: i32 = 520; +pub const SQLITE_READONLY_ROLLBACK: i32 = 776; +pub const SQLITE_READONLY_DBMOVED: i32 = 1032; +pub const SQLITE_READONLY_CANTINIT: i32 = 1288; +pub const SQLITE_READONLY_DIRECTORY: i32 = 1544; +pub const SQLITE_ABORT_ROLLBACK: i32 = 516; +pub const SQLITE_CONSTRAINT_CHECK: i32 = 275; +pub const SQLITE_CONSTRAINT_COMMITHOOK: i32 = 531; +pub const SQLITE_CONSTRAINT_FOREIGNKEY: i32 = 787; +pub const SQLITE_CONSTRAINT_FUNCTION: i32 = 1043; +pub const SQLITE_CONSTRAINT_NOTNULL: i32 = 1299; +pub const SQLITE_CONSTRAINT_PRIMARYKEY: i32 = 1555; +pub const SQLITE_CONSTRAINT_TRIGGER: i32 = 1811; +pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067; +pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323; +pub const SQLITE_CONSTRAINT_ROWID: i32 = 2579; +pub const SQLITE_CONSTRAINT_PINNED: i32 = 2835; +pub const SQLITE_NOTICE_RECOVER_WAL: i32 = 283; +pub const SQLITE_NOTICE_RECOVER_ROLLBACK: i32 = 539; +pub const SQLITE_WARNING_AUTOINDEX: i32 = 284; +pub const SQLITE_AUTH_USER: i32 = 279; +pub const SQLITE_OK_LOAD_PERMANENTLY: i32 = 256; +pub const SQLITE_OK_SYMLINK: i32 = 512; +pub const SQLITE_OPEN_READONLY: i32 = 1; +pub const SQLITE_OPEN_READWRITE: i32 = 2; +pub const SQLITE_OPEN_CREATE: i32 = 4; +pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; +pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; +pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; +pub const SQLITE_OPEN_URI: i32 = 64; +pub const SQLITE_OPEN_MEMORY: i32 = 128; +pub const SQLITE_OPEN_MAIN_DB: i32 = 256; +pub const SQLITE_OPEN_TEMP_DB: i32 = 512; +pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; +pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; +pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; +pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; +pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; +pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; +pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; +pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; +pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; +pub const SQLITE_OPEN_WAL: i32 = 524288; +pub const SQLITE_OPEN_NOFOLLOW: i32 = 16777216; +pub const SQLITE_IOCAP_ATOMIC: i32 = 1; +pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; +pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; +pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; +pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; +pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; +pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; +pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; +pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; +pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; +pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; +pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; +pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE: i32 = 4096; +pub const SQLITE_IOCAP_IMMUTABLE: i32 = 8192; +pub const SQLITE_IOCAP_BATCH_ATOMIC: i32 = 16384; +pub const SQLITE_LOCK_NONE: i32 = 0; +pub const SQLITE_LOCK_SHARED: i32 = 1; +pub const SQLITE_LOCK_RESERVED: i32 = 2; +pub const SQLITE_LOCK_PENDING: i32 = 3; +pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; +pub const SQLITE_SYNC_NORMAL: i32 = 2; +pub const SQLITE_SYNC_FULL: i32 = 3; +pub const SQLITE_SYNC_DATAONLY: i32 = 16; +pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; +pub const SQLITE_FCNTL_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_FCNTL_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_FCNTL_LAST_ERRNO: i32 = 4; +pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; +pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; +pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; +pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; +pub const SQLITE_FCNTL_WIN32_AV_RETRY: i32 = 9; +pub const SQLITE_FCNTL_PERSIST_WAL: i32 = 10; +pub const SQLITE_FCNTL_OVERWRITE: i32 = 11; +pub const SQLITE_FCNTL_VFSNAME: i32 = 12; +pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE: i32 = 13; +pub const SQLITE_FCNTL_PRAGMA: i32 = 14; +pub const SQLITE_FCNTL_BUSYHANDLER: i32 = 15; +pub const SQLITE_FCNTL_TEMPFILENAME: i32 = 16; +pub const SQLITE_FCNTL_MMAP_SIZE: i32 = 18; +pub const SQLITE_FCNTL_TRACE: i32 = 19; +pub const SQLITE_FCNTL_HAS_MOVED: i32 = 20; +pub const SQLITE_FCNTL_SYNC: i32 = 21; +pub const SQLITE_FCNTL_COMMIT_PHASETWO: i32 = 22; +pub const SQLITE_FCNTL_WIN32_SET_HANDLE: i32 = 23; +pub const SQLITE_FCNTL_WAL_BLOCK: i32 = 24; +pub const SQLITE_FCNTL_ZIPVFS: i32 = 25; +pub const SQLITE_FCNTL_RBU: i32 = 26; +pub const SQLITE_FCNTL_VFS_POINTER: i32 = 27; +pub const SQLITE_FCNTL_JOURNAL_POINTER: i32 = 28; +pub const SQLITE_FCNTL_WIN32_GET_HANDLE: i32 = 29; +pub const SQLITE_FCNTL_PDB: i32 = 30; +pub const SQLITE_FCNTL_BEGIN_ATOMIC_WRITE: i32 = 31; +pub const SQLITE_FCNTL_COMMIT_ATOMIC_WRITE: i32 = 32; +pub const SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE: i32 = 33; +pub const SQLITE_FCNTL_LOCK_TIMEOUT: i32 = 34; +pub const SQLITE_FCNTL_DATA_VERSION: i32 = 35; +pub const SQLITE_FCNTL_SIZE_LIMIT: i32 = 36; +pub const SQLITE_FCNTL_CKPT_DONE: i32 = 37; +pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_LAST_ERRNO: i32 = 4; +pub const SQLITE_ACCESS_EXISTS: i32 = 0; +pub const SQLITE_ACCESS_READWRITE: i32 = 1; +pub const SQLITE_ACCESS_READ: i32 = 2; +pub const SQLITE_SHM_UNLOCK: i32 = 1; +pub const SQLITE_SHM_LOCK: i32 = 2; +pub const SQLITE_SHM_SHARED: i32 = 4; +pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; +pub const SQLITE_SHM_NLOCK: i32 = 8; +pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; +pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; +pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; +pub const SQLITE_CONFIG_MALLOC: i32 = 4; +pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; +pub const SQLITE_CONFIG_SCRATCH: i32 = 6; +pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; +pub const SQLITE_CONFIG_HEAP: i32 = 8; +pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; +pub const SQLITE_CONFIG_MUTEX: i32 = 10; +pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; +pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; +pub const SQLITE_CONFIG_PCACHE: i32 = 14; +pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; +pub const SQLITE_CONFIG_LOG: i32 = 16; +pub const SQLITE_CONFIG_URI: i32 = 17; +pub const SQLITE_CONFIG_PCACHE2: i32 = 18; +pub const SQLITE_CONFIG_GETPCACHE2: i32 = 19; +pub const SQLITE_CONFIG_COVERING_INDEX_SCAN: i32 = 20; +pub const SQLITE_CONFIG_SQLLOG: i32 = 21; +pub const SQLITE_CONFIG_MMAP_SIZE: i32 = 22; +pub const SQLITE_CONFIG_WIN32_HEAPSIZE: i32 = 23; +pub const SQLITE_CONFIG_PCACHE_HDRSZ: i32 = 24; +pub const SQLITE_CONFIG_PMASZ: i32 = 25; +pub const SQLITE_CONFIG_STMTJRNL_SPILL: i32 = 26; +pub const SQLITE_CONFIG_SMALL_MALLOC: i32 = 27; +pub const SQLITE_CONFIG_SORTERREF_SIZE: i32 = 28; +pub const SQLITE_CONFIG_MEMDB_MAXSIZE: i32 = 29; +pub const SQLITE_DBCONFIG_MAINDBNAME: i32 = 1000; +pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; +pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; +pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; +pub const SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: i32 = 1004; +pub const SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: i32 = 1005; +pub const SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE: i32 = 1006; +pub const SQLITE_DBCONFIG_ENABLE_QPSG: i32 = 1007; +pub const SQLITE_DBCONFIG_TRIGGER_EQP: i32 = 1008; +pub const SQLITE_DBCONFIG_RESET_DATABASE: i32 = 1009; +pub const SQLITE_DBCONFIG_DEFENSIVE: i32 = 1010; +pub const SQLITE_DBCONFIG_WRITABLE_SCHEMA: i32 = 1011; +pub const SQLITE_DBCONFIG_LEGACY_ALTER_TABLE: i32 = 1012; +pub const SQLITE_DBCONFIG_DQS_DML: i32 = 1013; +pub const SQLITE_DBCONFIG_DQS_DDL: i32 = 1014; +pub const SQLITE_DBCONFIG_ENABLE_VIEW: i32 = 1015; +pub const SQLITE_DBCONFIG_LEGACY_FILE_FORMAT: i32 = 1016; +pub const SQLITE_DBCONFIG_TRUSTED_SCHEMA: i32 = 1017; +pub const SQLITE_DBCONFIG_MAX: i32 = 1017; +pub const SQLITE_DENY: i32 = 1; +pub const SQLITE_IGNORE: i32 = 2; +pub const SQLITE_CREATE_INDEX: i32 = 1; +pub const SQLITE_CREATE_TABLE: i32 = 2; +pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; +pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; +pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; +pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; +pub const SQLITE_CREATE_TRIGGER: i32 = 7; +pub const SQLITE_CREATE_VIEW: i32 = 8; +pub const SQLITE_DELETE: i32 = 9; +pub const SQLITE_DROP_INDEX: i32 = 10; +pub const SQLITE_DROP_TABLE: i32 = 11; +pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; +pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; +pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; +pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; +pub const SQLITE_DROP_TRIGGER: i32 = 16; +pub const SQLITE_DROP_VIEW: i32 = 17; +pub const SQLITE_INSERT: i32 = 18; +pub const SQLITE_PRAGMA: i32 = 19; +pub const SQLITE_READ: i32 = 20; +pub const SQLITE_SELECT: i32 = 21; +pub const SQLITE_TRANSACTION: i32 = 22; +pub const SQLITE_UPDATE: i32 = 23; +pub const SQLITE_ATTACH: i32 = 24; +pub const SQLITE_DETACH: i32 = 25; +pub const SQLITE_ALTER_TABLE: i32 = 26; +pub const SQLITE_REINDEX: i32 = 27; +pub const SQLITE_ANALYZE: i32 = 28; +pub const SQLITE_CREATE_VTABLE: i32 = 29; +pub const SQLITE_DROP_VTABLE: i32 = 30; +pub const SQLITE_FUNCTION: i32 = 31; +pub const SQLITE_SAVEPOINT: i32 = 32; +pub const SQLITE_COPY: i32 = 0; +pub const SQLITE_RECURSIVE: i32 = 33; +pub const SQLITE_TRACE_STMT: i32 = 1; +pub const SQLITE_TRACE_PROFILE: i32 = 2; +pub const SQLITE_TRACE_ROW: i32 = 4; +pub const SQLITE_TRACE_CLOSE: i32 = 8; +pub const SQLITE_LIMIT_LENGTH: i32 = 0; +pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; +pub const SQLITE_LIMIT_COLUMN: i32 = 2; +pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; +pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; +pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; +pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; +pub const SQLITE_LIMIT_ATTACHED: i32 = 7; +pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; +pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; +pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; +pub const SQLITE_LIMIT_WORKER_THREADS: i32 = 11; +pub const SQLITE_PREPARE_PERSISTENT: i32 = 1; +pub const SQLITE_PREPARE_NORMALIZE: i32 = 2; +pub const SQLITE_PREPARE_NO_VTAB: i32 = 4; +pub const SQLITE_INTEGER: i32 = 1; +pub const SQLITE_FLOAT: i32 = 2; +pub const SQLITE_BLOB: i32 = 4; +pub const SQLITE_NULL: i32 = 5; +pub const SQLITE_TEXT: i32 = 3; +pub const SQLITE3_TEXT: i32 = 3; +pub const SQLITE_UTF8: i32 = 1; +pub const SQLITE_UTF16LE: i32 = 2; +pub const SQLITE_UTF16BE: i32 = 3; +pub const SQLITE_UTF16: i32 = 4; +pub const SQLITE_ANY: i32 = 5; +pub const SQLITE_UTF16_ALIGNED: i32 = 8; +pub const SQLITE_DETERMINISTIC: i32 = 2048; +pub const SQLITE_DIRECTONLY: i32 = 524288; +pub const SQLITE_SUBTYPE: i32 = 1048576; +pub const SQLITE_INNOCUOUS: i32 = 2097152; +pub const SQLITE_WIN32_DATA_DIRECTORY_TYPE: i32 = 1; +pub const SQLITE_WIN32_TEMP_DIRECTORY_TYPE: i32 = 2; +pub const SQLITE_INDEX_SCAN_UNIQUE: i32 = 1; +pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; +pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; +pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; +pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; +pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; +pub const SQLITE_INDEX_CONSTRAINT_LIKE: i32 = 65; +pub const SQLITE_INDEX_CONSTRAINT_GLOB: i32 = 66; +pub const SQLITE_INDEX_CONSTRAINT_REGEXP: i32 = 67; +pub const SQLITE_INDEX_CONSTRAINT_NE: i32 = 68; +pub const SQLITE_INDEX_CONSTRAINT_ISNOT: i32 = 69; +pub const SQLITE_INDEX_CONSTRAINT_ISNOTNULL: i32 = 70; +pub const SQLITE_INDEX_CONSTRAINT_ISNULL: i32 = 71; +pub const SQLITE_INDEX_CONSTRAINT_IS: i32 = 72; +pub const SQLITE_INDEX_CONSTRAINT_FUNCTION: i32 = 150; +pub const SQLITE_MUTEX_FAST: i32 = 0; +pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; +pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; +pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; +pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; +pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; +pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; +pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; +pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; +pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; +pub const SQLITE_MUTEX_STATIC_APP1: i32 = 8; +pub const SQLITE_MUTEX_STATIC_APP2: i32 = 9; +pub const SQLITE_MUTEX_STATIC_APP3: i32 = 10; +pub const SQLITE_MUTEX_STATIC_VFS1: i32 = 11; +pub const SQLITE_MUTEX_STATIC_VFS2: i32 = 12; +pub const SQLITE_MUTEX_STATIC_VFS3: i32 = 13; +pub const SQLITE_TESTCTRL_FIRST: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; +pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; +pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; +pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; +pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; +pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; +pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; +pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; +pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; +pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; +pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; +pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 17; +pub const SQLITE_TESTCTRL_INTERNAL_FUNCTIONS: i32 = 17; +pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 18; +pub const SQLITE_TESTCTRL_EXPLAIN_STMT: i32 = 19; +pub const SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD: i32 = 19; +pub const SQLITE_TESTCTRL_NEVER_CORRUPT: i32 = 20; +pub const SQLITE_TESTCTRL_VDBE_COVERAGE: i32 = 21; +pub const SQLITE_TESTCTRL_BYTEORDER: i32 = 22; +pub const SQLITE_TESTCTRL_ISINIT: i32 = 23; +pub const SQLITE_TESTCTRL_SORTER_MMAP: i32 = 24; +pub const SQLITE_TESTCTRL_IMPOSTER: i32 = 25; +pub const SQLITE_TESTCTRL_PARSER_COVERAGE: i32 = 26; +pub const SQLITE_TESTCTRL_RESULT_INTREAL: i32 = 27; +pub const SQLITE_TESTCTRL_PRNG_SEED: i32 = 28; +pub const SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS: i32 = 29; +pub const SQLITE_TESTCTRL_LAST: i32 = 29; +pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; +pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; +pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; +pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; +pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; +pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; +pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; +pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; +pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; +pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; +pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; +pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; +pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; +pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; +pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; +pub const SQLITE_DBSTATUS_CACHE_HIT: i32 = 7; +pub const SQLITE_DBSTATUS_CACHE_MISS: i32 = 8; +pub const SQLITE_DBSTATUS_CACHE_WRITE: i32 = 9; +pub const SQLITE_DBSTATUS_DEFERRED_FKS: i32 = 10; +pub const SQLITE_DBSTATUS_CACHE_USED_SHARED: i32 = 11; +pub const SQLITE_DBSTATUS_CACHE_SPILL: i32 = 12; +pub const SQLITE_DBSTATUS_MAX: i32 = 12; +pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; +pub const SQLITE_STMTSTATUS_SORT: i32 = 2; +pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; +pub const SQLITE_STMTSTATUS_VM_STEP: i32 = 4; +pub const SQLITE_STMTSTATUS_REPREPARE: i32 = 5; +pub const SQLITE_STMTSTATUS_RUN: i32 = 6; +pub const SQLITE_STMTSTATUS_MEMUSED: i32 = 99; +pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; +pub const SQLITE_CHECKPOINT_FULL: i32 = 1; +pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; +pub const SQLITE_CHECKPOINT_TRUNCATE: i32 = 3; +pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; +pub const SQLITE_VTAB_INNOCUOUS: i32 = 2; +pub const SQLITE_VTAB_DIRECTONLY: i32 = 3; +pub const SQLITE_ROLLBACK: i32 = 1; +pub const SQLITE_FAIL: i32 = 3; +pub const SQLITE_REPLACE: i32 = 5; +pub const SQLITE_SCANSTAT_NLOOP: i32 = 0; +pub const SQLITE_SCANSTAT_NVISIT: i32 = 1; +pub const SQLITE_SCANSTAT_EST: i32 = 2; +pub const SQLITE_SCANSTAT_NAME: i32 = 3; +pub const SQLITE_SCANSTAT_EXPLAIN: i32 = 4; +pub const SQLITE_SCANSTAT_SELECTID: i32 = 5; +pub const SQLITE_SERIALIZE_NOCOPY: i32 = 1; +pub const SQLITE_DESERIALIZE_FREEONCLOSE: i32 = 1; +pub const SQLITE_DESERIALIZE_RESIZEABLE: i32 = 2; +pub const SQLITE_DESERIALIZE_READONLY: i32 = 4; +pub const NOT_WITHIN: i32 = 0; +pub const PARTLY_WITHIN: i32 = 1; +pub const FULLY_WITHIN: i32 = 2; +pub const FTS5_TOKENIZE_QUERY: i32 = 1; +pub const FTS5_TOKENIZE_PREFIX: i32 = 2; +pub const FTS5_TOKENIZE_DOCUMENT: i32 = 4; +pub const FTS5_TOKENIZE_AUX: i32 = 8; +pub const FTS5_TOKEN_COLOCATED: i32 = 1; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; +extern "C" { + pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3 { + _unused: [u8; 0], +} +pub type sqlite_int64 = ::std::os::raw::c_longlong; +pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; +pub type sqlite3_int64 = sqlite_int64; +pub type sqlite3_uint64 = sqlite_uint64; +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_file { + pub pMethods: *const sqlite3_io_methods, +} +#[test] +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xShmMap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iPg: ::std::os::raw::c_int, + pgsz: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xShmLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + offset: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xShmBarrier: ::std::option::Option, + pub xShmUnmap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + deleteFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iOfst: sqlite3_int64, + iAmt: ::std::os::raw::c_int, + pp: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xUnfetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iOfst: sqlite3_int64, + p: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 152usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmMap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmBarrier) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmUnmap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnfetch as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnfetch) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +pub type sqlite3_syscall_ptr = ::std::option::Option; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vfs { + pub iVersion: ::std::os::raw::c_int, + pub szOsFile: ::std::os::raw::c_int, + pub mxPathname: ::std::os::raw::c_int, + pub pNext: *mut sqlite3_vfs, + pub zName: *const ::std::os::raw::c_char, + pub pAppData: *mut ::std::os::raw::c_void, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTimeInt64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xSetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: sqlite3_syscall_ptr, + ) -> ::std::os::raw::c_int, + >, + pub xGetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> sqlite3_syscall_ptr, + >, + pub xNextSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_vfs() { + assert_eq!( + ::std::mem::size_of::(), + 168usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTimeInt64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xNextSystemCall) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mem_methods { + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub pAppData: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_mem_methods() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_stmt { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_value { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_context { + _unused: [u8; 0], +} +pub type sqlite3_destructor_type = + ::std::option::Option; +extern "C" { + pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; +} +extern "C" { + pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSavepoint: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRelease: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRollbackTo: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xShadowName: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 192usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSavepoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRelease) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollbackTo) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShadowName as *const _ as usize }, + 184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xShadowName) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info { + pub nConstraint: ::std::os::raw::c_int, + pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, + pub nOrderBy: ::std::os::raw::c_int, + pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, + pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, + pub idxNum: ::std::os::raw::c_int, + pub idxStr: *mut ::std::os::raw::c_char, + pub needToFreeIdxStr: ::std::os::raw::c_int, + pub orderByConsumed: ::std::os::raw::c_int, + pub estimatedCost: f64, + pub estimatedRows: sqlite3_int64, + pub idxFlags: ::std::os::raw::c_int, + pub colUsed: sqlite3_uint64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint { + pub iColumn: ::std::os::raw::c_int, + pub op: ::std::os::raw::c_uchar, + pub usable: ::std::os::raw::c_uchar, + pub iTermOffset: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_orderby { + pub iColumn: ::std::os::raw::c_int, + pub desc: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint_usage { + pub argvIndex: ::std::os::raw::c_int, + pub omit: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); +} +#[test] +fn bindgen_test_layout_sqlite3_index_info() { + assert_eq!( + ::std::mem::size_of::(), + 96usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedRows as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedRows) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxFlags as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxFlags) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).colUsed as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(colUsed) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_blob { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex_methods { + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_mutex_methods() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_str { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_page { + pub pBuf: *mut ::std::os::raw::c_void, + pub pExtra: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_page() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pBuf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pExtra) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods2 { + pub iVersion: ::std::os::raw::c_int, + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + szExtra: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache_page, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, + pub xShrink: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods2() { + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iVersion as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDestroy as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShrink) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods { + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_backup { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct sqlite3_snapshot { + pub hidden: [::std::os::raw::c_uchar; 48usize], +} +#[test] +fn bindgen_test_layout_sqlite3_snapshot() { + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!("Size of: ", stringify!(sqlite3_snapshot)) + ); + assert_eq!( + ::std::mem::align_of::(), + 1usize, + concat!("Alignment of ", stringify!(sqlite3_snapshot)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).hidden as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_snapshot), + "::", + stringify!(hidden) + ) + ); +} +pub type sqlite3_rtree_dbl = f64; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_geometry { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut sqlite3_rtree_dbl, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_geometry() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(xDelUser) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_query_info { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut sqlite3_rtree_dbl, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, + pub aCoord: *mut sqlite3_rtree_dbl, + pub anQueue: *mut ::std::os::raw::c_uint, + pub nCoord: ::std::os::raw::c_int, + pub iLevel: ::std::os::raw::c_int, + pub mxLevel: ::std::os::raw::c_int, + pub iRowid: sqlite3_int64, + pub rParentScore: sqlite3_rtree_dbl, + pub eParentWithin: ::std::os::raw::c_int, + pub eWithin: ::std::os::raw::c_int, + pub rScore: sqlite3_rtree_dbl, + pub apSqlParam: *mut *mut sqlite3_value, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_query_info() { + assert_eq!( + ::std::mem::size_of::(), + 112usize, + concat!("Size of: ", stringify!(sqlite3_rtree_query_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_query_info)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).pContext as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDelUser as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(xDelUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aCoord as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(aCoord) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).anQueue as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(anQueue) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nCoord as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(nCoord) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iLevel as *const _ as usize }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(iLevel) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mxLevel as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(mxLevel) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iRowid as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(iRowid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rParentScore as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(rParentScore) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eParentWithin as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(eParentWithin) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).eWithin as *const _ as usize + }, + 92usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(eWithin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).rScore as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(rScore) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).apSqlParam as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_query_info), + "::", + stringify!(apSqlParam) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5Context { + _unused: [u8; 0], +} +pub type fts5_extension_function = ::std::option::Option< + unsafe extern "C" fn( + pApi: *const Fts5ExtensionApi, + pFts: *mut Fts5Context, + pCtx: *mut sqlite3_context, + nVal: ::std::os::raw::c_int, + apVal: *mut *mut sqlite3_value, + ), +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5PhraseIter { + pub a: *const ::std::os::raw::c_uchar, + pub b: *const ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_Fts5PhraseIter() { + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(Fts5PhraseIter)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Fts5PhraseIter)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).a as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Fts5PhraseIter), + "::", + stringify!(a) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).b as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Fts5PhraseIter), + "::", + stringify!(b) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5ExtensionApi { + pub iVersion: ::std::os::raw::c_int, + pub xUserData: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> *mut ::std::os::raw::c_void, + >, + pub xColumnCount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, + >, + pub xRowCount: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pnRow: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xColumnTotalSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pnToken: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTokenize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pText: *const ::std::os::raw::c_char, + nText: ::std::os::raw::c_int, + pCtx: *mut ::std::os::raw::c_void, + xToken: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + arg6: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseCount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, + >, + pub xPhraseSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xInstCount: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pnInst: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xInst: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iIdx: ::std::os::raw::c_int, + piPhrase: *mut ::std::os::raw::c_int, + piCol: *mut ::std::os::raw::c_int, + piOff: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: + ::std::option::Option sqlite3_int64>, + pub xColumnText: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pz: *mut *const ::std::os::raw::c_char, + pn: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xColumnSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iCol: ::std::os::raw::c_int, + pnToken: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xQueryPhrase: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + pUserData: *mut ::std::os::raw::c_void, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const Fts5ExtensionApi, + arg2: *mut Fts5Context, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub xSetAuxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + pAux: *mut ::std::os::raw::c_void, + xDelete: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub xGetAuxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + bClear: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xPhraseFirst: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + arg2: *mut Fts5PhraseIter, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseNext: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + arg2: *mut Fts5PhraseIter, + piCol: *mut ::std::os::raw::c_int, + piOff: *mut ::std::os::raw::c_int, + ), + >, + pub xPhraseFirstColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + iPhrase: ::std::os::raw::c_int, + arg2: *mut Fts5PhraseIter, + arg3: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xPhraseNextColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Context, + arg2: *mut Fts5PhraseIter, + piCol: *mut ::std::os::raw::c_int, + ), + >, +} +#[test] +fn bindgen_test_layout_Fts5ExtensionApi() { + assert_eq!( + ::std::mem::size_of::(), + 160usize, + concat!("Size of: ", stringify!(Fts5ExtensionApi)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(Fts5ExtensionApi)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUserData as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xUserData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnCount as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowCount as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xRowCount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xColumnTotalSize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnTotalSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xTokenize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseCount as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseSize as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInstCount as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xInstCount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInst as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xInst) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnText as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnText) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumnSize as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xColumnSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xQueryPhrase as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xQueryPhrase) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetAuxdata as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xSetAuxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetAuxdata as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xGetAuxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseFirst as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseFirst) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xPhraseNext as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseNext) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPhraseFirstColumn as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseFirstColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPhraseNextColumn as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(Fts5ExtensionApi), + "::", + stringify!(xPhraseNextColumn) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Fts5Tokenizer { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct fts5_tokenizer { + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + azArg: *mut *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ppOut: *mut *mut Fts5Tokenizer, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option, + pub xTokenize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut Fts5Tokenizer, + pCtx: *mut ::std::os::raw::c_void, + flags: ::std::os::raw::c_int, + pText: *const ::std::os::raw::c_char, + nText: ::std::os::raw::c_int, + xToken: ::std::option::Option< + unsafe extern "C" fn( + pCtx: *mut ::std::os::raw::c_void, + tflags: ::std::os::raw::c_int, + pToken: *const ::std::os::raw::c_char, + nToken: ::std::os::raw::c_int, + iStart: ::std::os::raw::c_int, + iEnd: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_fts5_tokenizer() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(fts5_tokenizer)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(fts5_tokenizer)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(fts5_tokenizer), + "::", + stringify!(xTokenize) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct fts5_api { + pub iVersion: ::std::os::raw::c_int, + pub xCreateTokenizer: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + pContext: *mut ::std::os::raw::c_void, + pTokenizer: *mut fts5_tokenizer, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub xFindTokenizer: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + ppContext: *mut *mut ::std::os::raw::c_void, + pTokenizer: *mut fts5_tokenizer, + ) -> ::std::os::raw::c_int, + >, + pub xCreateFunction: ::std::option::Option< + unsafe extern "C" fn( + pApi: *mut fts5_api, + zName: *const ::std::os::raw::c_char, + pContext: *mut ::std::os::raw::c_void, + xFunction: fts5_extension_function, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_fts5_api() { + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!("Size of: ", stringify!(fts5_api)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(fts5_api)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreateTokenizer as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xCreateTokenizer) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindTokenizer as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xFindTokenizer) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreateFunction as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(fts5_api), + "::", + stringify!(xCreateFunction) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_api_routines { + pub aggregate_context: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub aggregate_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, + >, + pub bind_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_double: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int, + >, + pub bind_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, + ) -> ::std::os::raw::c_int, + >, + pub bind_null: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub bind_parameter_index: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub bind_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub busy_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub busy_timeout: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub changes: + ::std::option::Option ::std::os::raw::c_int>, + pub close: + ::std::option::Option ::std::os::raw::c_int>, + pub collation_needed: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub collation_needed16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub column_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_bytes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_bytes16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub column_database_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_database_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_decltype: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_decltype16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_double: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, + >, + pub column_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_int64: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, + >, + pub column_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_origin_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_origin_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_table_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_table_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar, + >, + pub column_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_type: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value, + >, + pub commit_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub complete: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub complete16: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub create_collation: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_collation16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_function16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_module: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub data_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub db_handle: + ::std::option::Option *mut sqlite3>, + pub declare_vtab: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub enable_shared_cache: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub errmsg: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, + >, + pub errmsg16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, + >, + pub exec: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub expired: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub finalize: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub free: ::std::option::Option, + pub free_table: + ::std::option::Option, + pub get_autocommit: + ::std::option::Option ::std::os::raw::c_int>, + pub get_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub get_table: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub global_recover: ::std::option::Option ::std::os::raw::c_int>, + pub interruptx: ::std::option::Option, + pub last_insert_rowid: + ::std::option::Option sqlite_int64>, + pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, + pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, + pub malloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub mprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub open16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub prepare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub profile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub progress_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ), + >, + pub realloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub result_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_double: + ::std::option::Option, + pub result_error: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_error16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_int64: + ::std::option::Option, + pub result_null: ::std::option::Option, + pub result_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16be: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16le: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_value: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), + >, + pub rollback_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub set_authorizer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub set_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, + ), + >, + pub xsnprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub step: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub table_column_metadata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub thread_cleanup: ::std::option::Option, + pub total_changes: + ::std::option::Option ::std::os::raw::c_int>, + pub trace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub transfer_bindings: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int, + >, + pub update_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub user_data: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, + >, + pub value_blob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_bytes16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_double: ::std::option::Option f64>, + pub value_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_int64: + ::std::option::Option sqlite_int64>, + pub value_numeric_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_text: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, + >, + pub value_text16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16be: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16le: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub vmprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub overload_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub prepare_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub clear_bindings: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub create_module_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_close: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int, + >, + pub blob_read: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_write: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub create_collation_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub file_control: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub memory_highwater: + ::std::option::Option sqlite3_int64>, + pub memory_used: ::std::option::Option sqlite3_int64>, + pub mutex_alloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub mutex_enter: ::std::option::Option, + pub mutex_free: ::std::option::Option, + pub mutex_leave: ::std::option::Option, + pub mutex_try: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub open_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub release_memory: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub result_error_nomem: ::std::option::Option, + pub result_error_toobig: + ::std::option::Option, + pub sleep: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub soft_heap_limit: ::std::option::Option, + pub vfs_find: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, + >, + pub vfs_register: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub vfs_unregister: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, + >, + pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, + pub result_zeroblob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_error_code: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub test_control: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, + >, + pub randomness: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), + >, + pub context_db_handle: + ::std::option::Option *mut sqlite3>, + pub extended_result_codes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub limit: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub next_stmt: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, + >, + pub sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, + >, + pub status: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub backup_finish: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_init: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, + ) -> *mut sqlite3_backup, + >, + pub backup_pagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_remaining: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_step: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub compileoption_get: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, + >, + pub compileoption_used: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub create_function_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub db_config: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int, + >, + pub db_mutex: + ::std::option::Option *mut sqlite3_mutex>, + pub db_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub extended_errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub log: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char, ...), + >, + pub soft_heap_limit64: + ::std::option::Option sqlite3_int64>, + pub sourceid: ::std::option::Option *const ::std::os::raw::c_char>, + pub stmt_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub strnicmp: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub unlock_notify: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub wal_autocheckpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub wal_checkpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub wal_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub blob_reopen: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob, arg2: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub vtab_config: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int, + >, + pub vtab_on_conflict: + ::std::option::Option ::std::os::raw::c_int>, + pub close_v2: + ::std::option::Option ::std::os::raw::c_int>, + pub db_filename: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, + pub db_readonly: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub db_release_memory: + ::std::option::Option ::std::os::raw::c_int>, + pub errstr: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, + >, + pub stmt_busy: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub stmt_readonly: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub stricmp: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub uri_boolean: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub uri_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64, + ) -> sqlite3_int64, + >, + pub uri_parameter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, + pub xvsnprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub wal_checkpoint_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub auto_extension: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_blob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + arg6: ::std::os::raw::c_uchar, + ) -> ::std::os::raw::c_int, + >, + pub cancel_auto_extension: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub load_extension: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub malloc64: ::std::option::Option< + unsafe extern "C" fn(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void, + >, + pub msize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64, + >, + pub realloc64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_uint64, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset_auto_extension: ::std::option::Option, + pub result_blob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + ), + >, + pub result_text64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + arg5: ::std::os::raw::c_uchar, + ), + >, + pub strglob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub value_dup: ::std::option::Option< + unsafe extern "C" fn(arg1: *const sqlite3_value) -> *mut sqlite3_value, + >, + pub value_free: ::std::option::Option, + pub result_zeroblob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: sqlite3_uint64, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_uint64, + ) -> ::std::os::raw::c_int, + >, + pub value_subtype: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint, + >, + pub result_subtype: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint), + >, + pub status64: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut sqlite3_int64, + arg3: *mut sqlite3_int64, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub strlike: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_uint, + ) -> ::std::os::raw::c_int, + >, + pub db_cacheflush: + ::std::option::Option ::std::os::raw::c_int>, + pub system_errno: + ::std::option::Option ::std::os::raw::c_int>, + pub trace_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_uint, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_uint, + arg2: *mut ::std::os::raw::c_void, + arg3: *mut ::std::os::raw::c_void, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub expanded_sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char, + >, + pub set_last_insert_rowid: + ::std::option::Option, + pub prepare_v3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_uint, + arg5: *mut *mut sqlite3_stmt, + arg6: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16_v3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_uint, + arg5: *mut *mut sqlite3_stmt, + arg6: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub bind_pointer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: *const ::std::os::raw::c_char, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub result_pointer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *mut ::std::os::raw::c_void, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::option::Option, + ), + >, + pub value_pointer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_value, + arg2: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub vtab_nochange: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, + >, + pub value_nochange: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub vtab_collation: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_index_info, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub keyword_count: ::std::option::Option ::std::os::raw::c_int>, + pub keyword_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut *const ::std::os::raw::c_char, + arg3: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub keyword_check: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub str_new: + ::std::option::Option *mut sqlite3_str>, + pub str_finish: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char, + >, + pub str_appendf: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_str, zFormat: *const ::std::os::raw::c_char, ...), + >, + pub str_vappendf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_str, + zFormat: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ), + >, + pub str_append: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_str, + zIn: *const ::std::os::raw::c_char, + N: ::std::os::raw::c_int, + ), + >, + pub str_appendall: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_str, zIn: *const ::std::os::raw::c_char), + >, + pub str_appendchar: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_str, + N: ::std::os::raw::c_int, + C: ::std::os::raw::c_char, + ), + >, + pub str_reset: ::std::option::Option, + pub str_errcode: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int, + >, + pub str_length: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int, + >, + pub str_value: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char, + >, + pub create_window_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xValue: ::std::option::Option, + xInv: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub normalized_sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, + >, + pub stmt_isexplain: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub value_frombind: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub drop_modules: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub hard_heap_limit64: + ::std::option::Option sqlite3_int64>, + pub uri_key: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub filename_database: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char, + >, + pub filename_journal: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char, + >, + pub filename_wal: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_api_routines() { + assert_eq!( + ::std::mem::size_of::(), + 1992usize, + concat!("Size of: ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_context as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_context) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_count as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_double as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_count as *const _ + as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_index as *const _ + as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_index) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_name as *const _ + as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text16 as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_handler as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_handler) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_timeout as *const _ as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_timeout) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed as *const _ as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_blob as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes as *const _ as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize + }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_count as *const _ as usize + }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name as *const _ + as usize + }, + 184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name16 as *const _ + as usize + }, + 192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype as *const _ as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize + }, + 208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_double as *const _ as usize + }, + 216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, + 224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_int64 as *const _ as usize + }, + 232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name as *const _ as usize + }, + 240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name16 as *const _ as usize + }, + 248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name as *const _ as usize + }, + 256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name16 as *const _ + as usize + }, + 264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name as *const _ as usize + }, + 272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name16 as *const _ + as usize + }, + 280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text as *const _ as usize + }, + 288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text16 as *const _ as usize + }, + 296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_type as *const _ as usize + }, + 304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_type) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_value as *const _ as usize + }, + 312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).commit_hook as *const _ as usize + }, + 320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(commit_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, + 328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, + 336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation as *const _ as usize + }, + 344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation16 as *const _ as usize + }, + 352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function as *const _ as usize + }, + 360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function16 as *const _ as usize + }, + 368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module as *const _ as usize + }, + 376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, + 384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(data_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, + 392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).declare_vtab as *const _ as usize + }, + 400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(declare_vtab) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).enable_shared_cache as *const _ + as usize + }, + 408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(enable_shared_cache) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, + 416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, + 424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, + 432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, + 440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(exec) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, + 448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(expired) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, + 456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(finalize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, + 464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, + 472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_autocommit as *const _ as usize + }, + 480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_autocommit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_auxdata as *const _ as usize + }, + 488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, + 496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).global_recover as *const _ as usize + }, + 504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(global_recover) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, + 512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(interruptx) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize + }, + 520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(last_insert_rowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, + 528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).libversion_number as *const _ as usize + }, + 536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion_number) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, + 544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, + 552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, + 560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, + 568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, + 576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, + 584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, + 592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(profile) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).progress_handler as *const _ as usize + }, + 600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(progress_handler) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, + 608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, + 616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob as *const _ as usize + }, + 624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_double as *const _ as usize + }, + 632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_double) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error as *const _ as usize + }, + 640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error16 as *const _ as usize + }, + 648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, + 656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_int64 as *const _ as usize + }, + 664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_null as *const _ as usize + }, + 672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text as *const _ as usize + }, + 680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16 as *const _ as usize + }, + 688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16be as *const _ as usize + }, + 696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16le as *const _ as usize + }, + 704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16le) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_value as *const _ as usize + }, + 712usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rollback_hook as *const _ as usize + }, + 720usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(rollback_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_authorizer as *const _ as usize + }, + 728usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_authorizer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_auxdata as *const _ as usize + }, + 736usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xsnprintf as *const _ as usize }, + 744usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xsnprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, + 752usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).table_column_metadata as *const _ + as usize + }, + 760usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(table_column_metadata) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize + }, + 768usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(thread_cleanup) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).total_changes as *const _ as usize + }, + 776usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(total_changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, + 784usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(trace) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize + }, + 792usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(transfer_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).update_hook as *const _ as usize + }, + 800usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(update_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, + 808usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(user_data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, + 816usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes as *const _ as usize + }, + 824usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize + }, + 832usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_double as *const _ as usize + }, + 840usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, + 848usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_int64 as *const _ as usize + }, + 856usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize + }, + 864usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_numeric_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, + 872usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16 as *const _ as usize + }, + 880usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16be as *const _ as usize + }, + 888usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16le as *const _ as usize + }, + 896usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16le) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, + 904usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, + 912usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vmprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).overload_function as *const _ as usize + }, + 920usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(overload_function) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, + 928usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize + }, + 936usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).clear_bindings as *const _ as usize + }, + 944usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(clear_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize + }, + 952usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize + }, + 960usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, + 968usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_bytes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, + 976usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_close) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, + 984usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, + 992usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_read) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, + 1000usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_write) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation_v2 as *const _ + as usize + }, + 1008usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).file_control as *const _ as usize + }, + 1016usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(file_control) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_highwater as *const _ as usize + }, + 1024usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_highwater) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_used as *const _ as usize + }, + 1032usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize + }, + 1040usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_alloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_enter as *const _ as usize + }, + 1048usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_enter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, + 1056usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_leave as *const _ as usize + }, + 1064usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_leave) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, + 1072usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_try) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, + 1080usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).release_memory as *const _ as usize + }, + 1088usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(release_memory) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize + }, + 1096usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_nomem) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_toobig as *const _ + as usize + }, + 1104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_toobig) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, + 1112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sleep) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize + }, + 1120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, + 1128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_find) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_register as *const _ as usize + }, + 1136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_register) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize + }, + 1144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_unregister) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize + }, + 1152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xthreadsafe) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize + }, + 1160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_code as *const _ as usize + }, + 1168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_code) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).test_control as *const _ as usize + }, + 1176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(test_control) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, + 1184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(randomness) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).context_db_handle as *const _ as usize + }, + 1192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(context_db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_result_codes as *const _ + as usize + }, + 1200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_result_codes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, + 1208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, + 1216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(next_stmt) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, + 1224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sql) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, + 1232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_finish as *const _ as usize + }, + 1240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_finish) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_init as *const _ as usize + }, + 1248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_init) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_pagecount as *const _ as usize + }, + 1256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_pagecount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_remaining as *const _ as usize + }, + 1264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_remaining) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_step as *const _ as usize + }, + 1272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_get as *const _ as usize + }, + 1280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_get) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_used as *const _ as usize + }, + 1288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function_v2 as *const _ as usize + }, + 1296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function_v2) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_config as *const _ as usize }, + 1304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_config) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_mutex as *const _ as usize }, + 1312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_mutex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_status as *const _ as usize }, + 1320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_errcode as *const _ as usize + }, + 1328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).log as *const _ as usize }, + 1336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(log) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit64 as *const _ as usize + }, + 1344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sourceid as *const _ as usize }, + 1352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sourceid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stmt_status as *const _ as usize + }, + 1360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_status) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strnicmp as *const _ as usize }, + 1368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strnicmp) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).unlock_notify as *const _ as usize + }, + 1376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(unlock_notify) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_autocheckpoint as *const _ as usize + }, + 1384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_autocheckpoint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_checkpoint as *const _ as usize + }, + 1392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_checkpoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).wal_hook as *const _ as usize }, + 1400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).blob_reopen as *const _ as usize + }, + 1408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_reopen) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_config as *const _ as usize + }, + 1416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_config) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_on_conflict as *const _ as usize + }, + 1424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_on_conflict) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close_v2 as *const _ as usize }, + 1432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_filename as *const _ as usize + }, + 1440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_filename) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_readonly as *const _ as usize + }, + 1448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_readonly) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_release_memory as *const _ as usize + }, + 1456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_release_memory) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errstr as *const _ as usize }, + 1464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errstr) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).stmt_busy as *const _ as usize }, + 1472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_busy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stmt_readonly as *const _ as usize + }, + 1480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_readonly) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).stricmp as *const _ as usize }, + 1488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stricmp) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).uri_boolean as *const _ as usize + }, + 1496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_boolean) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).uri_int64 as *const _ as usize }, + 1504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).uri_parameter as *const _ as usize + }, + 1512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_parameter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xvsnprintf as *const _ as usize }, + 1520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xvsnprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_checkpoint_v2 as *const _ as usize + }, + 1528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_checkpoint_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).auto_extension as *const _ as usize + }, + 1536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(auto_extension) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_blob64 as *const _ as usize + }, + 1544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text64 as *const _ as usize + }, + 1552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).cancel_auto_extension as *const _ + as usize + }, + 1560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(cancel_auto_extension) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).load_extension as *const _ as usize + }, + 1568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(load_extension) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc64 as *const _ as usize }, + 1576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).msize as *const _ as usize }, + 1584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(msize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc64 as *const _ as usize }, + 1592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).reset_auto_extension as *const _ + as usize + }, + 1600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset_auto_extension) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob64 as *const _ as usize + }, + 1608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text64 as *const _ as usize + }, + 1616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strglob as *const _ as usize }, + 1624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strglob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_dup as *const _ as usize }, + 1632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_dup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_free as *const _ as usize }, + 1640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob64 as *const _ as usize + }, + 1648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob64 as *const _ as usize + }, + 1656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_subtype as *const _ as usize + }, + 1664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_subtype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_subtype as *const _ as usize + }, + 1672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_subtype) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status64 as *const _ as usize }, + 1680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strlike as *const _ as usize }, + 1688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strlike) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).db_cacheflush as *const _ as usize + }, + 1696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_cacheflush) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).system_errno as *const _ as usize + }, + 1704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(system_errno) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).trace_v2 as *const _ as usize }, + 1712usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(trace_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).expanded_sql as *const _ as usize + }, + 1720usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(expanded_sql) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_last_insert_rowid as *const _ + as usize + }, + 1728usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_last_insert_rowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare_v3 as *const _ as usize }, + 1736usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare_v3) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).prepare16_v3 as *const _ as usize + }, + 1744usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16_v3) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_pointer as *const _ as usize + }, + 1752usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_pointer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_pointer as *const _ as usize + }, + 1760usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_pointer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_pointer as *const _ as usize + }, + 1768usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_pointer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_nochange as *const _ as usize + }, + 1776usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_nochange) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_nochange as *const _ as usize + }, + 1784usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_nochange) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vtab_collation as *const _ as usize + }, + 1792usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vtab_collation) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).keyword_count as *const _ as usize + }, + 1800usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(keyword_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).keyword_name as *const _ as usize + }, + 1808usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(keyword_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).keyword_check as *const _ as usize + }, + 1816usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(keyword_check) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).str_new as *const _ as usize }, + 1824usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_new) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).str_finish as *const _ as usize }, + 1832usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_finish) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).str_appendf as *const _ as usize + }, + 1840usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_appendf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).str_vappendf as *const _ as usize + }, + 1848usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_vappendf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).str_append as *const _ as usize }, + 1856usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_append) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).str_appendall as *const _ as usize + }, + 1864usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_appendall) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).str_appendchar as *const _ as usize + }, + 1872usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_appendchar) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).str_reset as *const _ as usize }, + 1880usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_reset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).str_errcode as *const _ as usize + }, + 1888usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).str_length as *const _ as usize }, + 1896usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_length) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).str_value as *const _ as usize }, + 1904usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_window_function as *const _ + as usize + }, + 1912usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_window_function) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).normalized_sql as *const _ as usize + }, + 1920usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(normalized_sql) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stmt_isexplain as *const _ as usize + }, + 1928usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_isexplain) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_frombind as *const _ as usize + }, + 1936usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_frombind) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).drop_modules as *const _ as usize + }, + 1944usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(drop_modules) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).hard_heap_limit64 as *const _ as usize + }, + 1952usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(hard_heap_limit64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).uri_key as *const _ as usize }, + 1960usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(uri_key) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).filename_database as *const _ as usize + }, + 1968usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(filename_database) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).filename_journal as *const _ as usize + }, + 1976usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(filename_journal) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).filename_wal as *const _ as usize + }, + 1984usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(filename_wal) + ) + ); +} +pub type sqlite3_loadext_entry = ::std::option::Option< + unsafe extern "C" fn( + db: *mut sqlite3, + pzErrMsg: *mut *mut ::std::os::raw::c_char, + pThunk: *const sqlite3_api_routines, + ) -> ::std::os::raw::c_int, +>; +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} + +// bindings were built with (non-embedded) loadable_extension: +// we define our own sqlite_api static variable and export it +// to C +#[no_mangle] +pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_routines; + +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) + +pub unsafe fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_context.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_context", + " function" + )))(arg1, nBytes) +} + +pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_double", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_null", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_index.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_index", + " function" + )))(arg1, zName) +} + +pub unsafe fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_value", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_handler", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_timeout.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_timeout", + " function" + )))(arg1, ms) +} + +pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_blob", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype", + " function" + )))(arg1, i) +} + +pub unsafe fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_double", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int64", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_type", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_value", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).commit_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "commit_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete16", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_create_collation( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_collation16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_function( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_function16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function16", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_module( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).data_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "data_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).declare_vtab.expect(stringify!( + "sqlite3_api contains null pointer for ", + "declare_vtab", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).enable_shared_cache.expect(stringify!( + "sqlite3_api contains null pointer for ", + "enable_shared_cache", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errcode", + " function" + )))(db) +} + +pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_exec( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).exec.expect(stringify!( + "sqlite3_api contains null pointer for ", + "exec", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).expired.expect(stringify!( + "sqlite3_api contains null pointer for ", + "expired", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).finalize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "finalize", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free_table", + " function" + )))(result) +} + +pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_autocommit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_autocommit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_auxdata", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_get_table( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_table", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).global_recover.expect(stringify!( + "sqlite3_api contains null pointer for ", + "global_recover", + " function" + )))() +} + +pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).interruptx.expect(stringify!( + "sqlite3_api contains null pointer for ", + "interruptx", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).last_insert_rowid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "last_insert_rowid", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion", + " function" + )))() +} + +pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion_number.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion_number", + " function" + )))() +} + +pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mprintf( + arg1: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mprintf", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_open( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_open16( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_prepare( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_profile( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).profile.expect(stringify!( + "sqlite3_api contains null pointer for ", + "profile", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).progress_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "progress_handler", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_double", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_null", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16be", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16le", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_value", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).rollback_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "rollback_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_authorizer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_authorizer", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_auxdata", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_xsnprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xsnprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xsnprintf", + " function" + )))(arg1, arg2, arg3, vararg1) +} + +pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "step", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_table_column_metadata( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).table_column_metadata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "table_column_metadata", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) +} + +pub unsafe fn sqlite3_thread_cleanup() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).thread_cleanup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "thread_cleanup", + " function" + )))() +} + +pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).total_changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "total_changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).trace.expect(stringify!( + "sqlite3_api contains null pointer for ", + "trace", + " function" + )))(arg1, xTrace, arg2) +} + +pub unsafe fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).transfer_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "transfer_bindings", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).update_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "update_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).user_data.expect(stringify!( + "sqlite3_api contains null pointer for ", + "user_data", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_blob", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_double", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_numeric_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_numeric_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16be", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16le", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vmprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vmprintf", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).overload_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "overload_function", + " function" + )))(arg1, zFuncName, nArg) +} + +pub unsafe fn sqlite3_prepare_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).clear_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "clear_bindings", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_module_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module_v2", + " function" + )))(arg1, arg2, arg3, arg4, xDestroy) +} + +pub unsafe fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_open( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_open", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) +} + +pub unsafe fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_read.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_read", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_write.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_write", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_file_control( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).file_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "file_control", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_highwater.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_highwater", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_used", + " function" + )))() +} + +pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_alloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_alloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_enter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_enter", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_leave.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_leave", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_try.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_try", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_open_v2( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open_v2", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_nomem.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_nomem", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_toobig.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_toobig", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sleep.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sleep", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_find.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_find", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_register.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_register", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_unregister.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_unregister", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xthreadsafe.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xthreadsafe", + " function" + )))() +} + +pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_code.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_code", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_test_control( + arg1: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).test_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "test_control", + " function" + )))(arg1, vararg1) +} + +pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).randomness.expect(stringify!( + "sqlite3_api contains null pointer for ", + "randomness", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).context_db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "context_db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_result_codes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_result_codes", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_limit( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "limit", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).next_stmt.expect(stringify!( + "sqlite3_api contains null pointer for ", + "next_stmt", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_status( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_finish.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_finish", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_init( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, +) -> *mut sqlite3_backup { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_init.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_init", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_pagecount.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_pagecount", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_remaining.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_remaining", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_step( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_step", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_compileoption_get( + arg1: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_get.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_get", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_compileoption_used( + arg1: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_used", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_function_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal, xDestroy) +} + +pub unsafe fn sqlite3_db_config( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, + vararg2: &mut i32, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_config", + " function" + )))(arg1, arg2, vararg1, vararg2) +} + +pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_mutex.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_mutex", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_db_status( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_status", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_errcode", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_log( + arg1: ::std::os::raw::c_int, + arg2: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).log.expect(stringify!( + "sqlite3_api contains null pointer for ", + "log", + " function" + )))(arg1, arg2, vararg1) +} + +pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sourceid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sourceid", + " function" + )))() +} + +pub unsafe fn sqlite3_stmt_status( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_status", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_strnicmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strnicmp.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strnicmp", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_unlock_notify( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int), + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).unlock_notify.expect(stringify!( + "sqlite3_api contains null pointer for ", + "unlock_notify", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_wal_autocheckpoint( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_autocheckpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_checkpoint( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_checkpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_checkpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_reopen( + arg1: *mut sqlite3_blob, + arg2: sqlite3_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_reopen.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_reopen", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vtab_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_config", + " function" + )))(arg1, op, vararg1) +} + +pub unsafe fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_on_conflict.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_on_conflict", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close_v2", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_db_filename( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_filename.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_filename", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_db_readonly( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_readonly.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_readonly", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errstr.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errstr", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_busy.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_busy", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stmt_readonly(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_readonly.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_readonly", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stricmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stricmp.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stricmp", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_uri_boolean( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_boolean.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_boolean", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_uri_int64( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64, +) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_uri_parameter( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_parameter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_parameter", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_xvsnprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xvsnprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xvsnprintf", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_wal_checkpoint_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_checkpoint_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_checkpoint_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_auto_extension( + arg1: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).auto_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "auto_extension", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob64", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_text64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: sqlite3_uint64, + arg5: ::std::option::Option, + arg6: ::std::os::raw::c_uchar, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text64", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_cancel_auto_extension( + arg1: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).cancel_auto_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "cancel_auto_extension", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_load_extension( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).load_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "load_extension", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_malloc64(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_msize(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).msize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "msize", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_realloc64( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_uint64, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset_auto_extension() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset_auto_extension.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset_auto_extension", + " function" + )))() +} + +pub unsafe fn sqlite3_result_blob64( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob64", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text64( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + arg4: ::std::option::Option, + arg5: ::std::os::raw::c_uchar, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text64", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_strglob( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strglob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strglob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_value_dup(arg1: *const sqlite3_value) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_dup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_dup", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_free(arg1: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_zeroblob64( + arg1: *mut sqlite3_context, + arg2: sqlite3_uint64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_zeroblob64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_uint64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_value_subtype(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_subtype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_subtype", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_subtype(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_subtype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_subtype", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_status64( + arg1: ::std::os::raw::c_int, + arg2: *mut sqlite3_int64, + arg3: *mut sqlite3_int64, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status64", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_strlike( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_uint, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strlike.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strlike", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_db_cacheflush(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_cacheflush.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_cacheflush", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_system_errno(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).system_errno.expect(stringify!( + "sqlite3_api contains null pointer for ", + "system_errno", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_trace_v2( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_uint, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_uint, + arg2: *mut ::std::os::raw::c_void, + arg3: *mut ::std::os::raw::c_void, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).trace_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "trace_v2", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_expanded_sql(arg1: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).expanded_sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "expanded_sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_set_last_insert_rowid(arg1: *mut sqlite3, arg2: sqlite3_int64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_last_insert_rowid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_last_insert_rowid", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_prepare_v3( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_uint, + arg5: *mut *mut sqlite3_stmt, + arg6: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare_v3.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare_v3", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_prepare16_v3( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_uint, + arg5: *mut *mut sqlite3_stmt, + arg6: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16_v3.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16_v3", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_bind_pointer( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: *const ::std::os::raw::c_char, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_pointer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_pointer", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_result_pointer( + arg1: *mut sqlite3_context, + arg2: *mut ::std::os::raw::c_void, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_pointer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_pointer", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_value_pointer( + arg1: *mut sqlite3_value, + arg2: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_pointer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_pointer", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vtab_nochange(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_nochange.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_nochange", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_nochange(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_nochange.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_nochange", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vtab_collation( + arg1: *mut sqlite3_index_info, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_collation.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_collation", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_keyword_count() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).keyword_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "keyword_count", + " function" + )))() +} + +pub unsafe fn sqlite3_keyword_name( + arg1: ::std::os::raw::c_int, + arg2: *mut *const ::std::os::raw::c_char, + arg3: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).keyword_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "keyword_name", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_keyword_check( + arg1: *const ::std::os::raw::c_char, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).keyword_check.expect(stringify!( + "sqlite3_api contains null pointer for ", + "keyword_check", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_str_new(arg1: *mut sqlite3) -> *mut sqlite3_str { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_new.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_new", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_str_finish(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_finish.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_finish", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_str_appendf( + arg1: *mut sqlite3_str, + zFormat: *const ::std::os::raw::c_char, + vararg1: *const ::std::os::raw::c_char, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_appendf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_appendf", + " function" + )))(arg1, zFormat, vararg1) +} + +pub unsafe fn sqlite3_str_vappendf( + arg1: *mut sqlite3_str, + zFormat: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_vappendf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_vappendf", + " function" + )))(arg1, zFormat, arg2) +} + +pub unsafe fn sqlite3_str_append( + arg1: *mut sqlite3_str, + zIn: *const ::std::os::raw::c_char, + N: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_append.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_append", + " function" + )))(arg1, zIn, N) +} + +pub unsafe fn sqlite3_str_appendall(arg1: *mut sqlite3_str, zIn: *const ::std::os::raw::c_char) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_appendall.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_appendall", + " function" + )))(arg1, zIn) +} + +pub unsafe fn sqlite3_str_appendchar( + arg1: *mut sqlite3_str, + N: ::std::os::raw::c_int, + C: ::std::os::raw::c_char, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_appendchar.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_appendchar", + " function" + )))(arg1, N, C) +} + +pub unsafe fn sqlite3_str_reset(arg1: *mut sqlite3_str) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_reset.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_reset", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_str_errcode(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_errcode", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_str_length(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_length.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_length", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_str_value(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_value", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_window_function( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xValue: ::std::option::Option, + xInv: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_window_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_window_function", + " function" + )))( + arg1, arg2, arg3, arg4, arg5, xStep, xFinal, xValue, xInv, xDestroy, + ) +} + +pub unsafe fn sqlite3_normalized_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).normalized_sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "normalized_sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_stmt_isexplain(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_isexplain.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_isexplain", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_frombind(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_frombind.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_frombind", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_drop_modules( + arg1: *mut sqlite3, + arg2: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).drop_modules.expect(stringify!( + "sqlite3_api contains null pointer for ", + "drop_modules", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_hard_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).hard_heap_limit64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "hard_heap_limit64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_uri_key( + arg1: *const ::std::os::raw::c_char, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).uri_key.expect(stringify!( + "sqlite3_api contains null pointer for ", + "uri_key", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_filename_database( + arg1: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).filename_database.expect(stringify!( + "sqlite3_api contains null pointer for ", + "filename_database", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_filename_journal( + arg1: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).filename_journal.expect(stringify!( + "sqlite3_api contains null pointer for ", + "filename_journal", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_filename_wal( + arg1: *const ::std::os::raw::c_char, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).filename_wal.expect(stringify!( + "sqlite3_api contains null pointer for ", + "filename_wal", + " function" + )))(arg1) +} From 3494e67f3c651202db033dae740ee652c4550dfd Mon Sep 17 00:00:00 2001 From: gwenn Date: Sat, 15 Feb 2020 12:08:47 +0000 Subject: [PATCH 14/61] Remove generate-bindgen-bindings script If we need to regenerate old bindings, we can still do it with upgrade.sh --- libsqlite3-sys/bindgen-bindings/README.md | 2 - .../generate-bindgen-bindings.sh | 73 ------------------- 2 files changed, 75 deletions(-) delete mode 100755 libsqlite3-sys/bindgen-bindings/generate-bindgen-bindings.sh diff --git a/libsqlite3-sys/bindgen-bindings/README.md b/libsqlite3-sys/bindgen-bindings/README.md index dd5a28bfc..55c9d2007 100644 --- a/libsqlite3-sys/bindgen-bindings/README.md +++ b/libsqlite3-sys/bindgen-bindings/README.md @@ -12,8 +12,6 @@ The general recipe for doing this is: Repeat the above process for each desired version, and also re-run each build using `--features "buildtime_bindgen,loadable_extension"` to generate the `-ext.h` versions to support sqlite3 loadable extensions. -The script `generate-bindgen-bindings.sh` will attempt to rebuild all of the prepackaged bindings. - sqlite3 amalgamation source links --------------------------------- The location of the amalgamation sources used to build these are: diff --git a/libsqlite3-sys/bindgen-bindings/generate-bindgen-bindings.sh b/libsqlite3-sys/bindgen-bindings/generate-bindgen-bindings.sh deleted file mode 100755 index 1f4e7d469..000000000 --- a/libsqlite3-sys/bindgen-bindings/generate-bindgen-bindings.sh +++ /dev/null @@ -1,73 +0,0 @@ -#!/bin/bash -############################################################################### -# Copyright (c) 2019 Genomics plc -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in -# all copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -# THE SOFTWARE. -############################################################################### -set -euf -o pipefail - -SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )" - -build_dir=$(mktemp -d) -function cleanup { - >&2 echo "deleting ${build_dir}" - rm -rf "${build_dir}" -} -trap cleanup EXIT - -function generate_bindgen_bindings() { - version=$1 - url=$2 - prefix=$3 - - >&2 echo "generating bindgen bindings for sqlite3 ${version} in ${build_dir}" - curl -sSf -o "${build_dir}/sqlite-amalgamation-${version}.zip" "${url}" - mkdir "${build_dir}/sqlite-${version}" - unzip -qq -d "${build_dir}/sqlite-${version}" "${build_dir}/sqlite-amalgamation-${version}.zip" - export SQLITE3_LIB_DIR="${build_dir}/sqlite-${version}/${prefix}" - export SQLITE3_INCLUDE_DIR="${build_dir}/sqlite-${version}/${prefix}" - manifest="${SCRIPT_DIR}/../Cargo.toml" - generate_bindgen_binding "${manifest}" "${build_dir}" "${SCRIPT_DIR}" "buildtime_bindgen" "${version}" - generate_bindgen_binding "${manifest}" "${build_dir}" "${SCRIPT_DIR}" "buildtime_bindgen,loadable_extension" "${version}-ext" - generate_bindgen_binding "${manifest}" "${build_dir}" "${SCRIPT_DIR}" "buildtime_bindgen,loadable_extension_embedded" "${version}-ext-embed" - >&2 echo "done generating bindings for sqlite ${version}" -} - -function generate_bindgen_binding { - manifest_path=$1 - build_dir=$2 - output_dir=$3 - features=$4 - output_base=$5 - - target_dir="${build_dir}/${output_base}/target" - output_path="${output_dir}/bindgen_${output_base}.rs" - - >&2 echo "calling cargo build on manifest ${manifest_path} building in ${target_dir} with features ${features}" - cargo build --manifest-path "${manifest_path}" --target-dir "${target_dir}" --features "${features}" -p libsqlite3-sys - bindgen_file=$(set +f ; find "${target_dir}/debug/build/libsqlite3-sys-"* -name bindgen.rs ; set -f) - if [[ "$(echo "${bindgen_file}" | wc -l)" != 1 ]]; then - >&2 echo "multiple bindgen files found in target directory: ${bindgen_file}" - exit 2 - fi - cp "${bindgen_file}" "${output_path}" -} - -generate_bindgen_bindings 3.7.16 https://sqlite.org/2013/sqlite-amalgamation-3071600.zip sqlite-amalgamation-3071600/ -generate_bindgen_bindings 3.6.8 https://sqlite.org/sqlite-amalgamation-3_6_8.zip ./ From 7dd7204aa519308d9c4bde405fca815938ab1717 Mon Sep 17 00:00:00 2001 From: gwenn Date: Sat, 15 Feb 2020 14:17:17 +0000 Subject: [PATCH 15/61] Upgrade syn / quote --- libsqlite3-sys/Cargo.toml | 4 ++-- libsqlite3-sys/build.rs | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/libsqlite3-sys/Cargo.toml b/libsqlite3-sys/Cargo.toml index b3aae2b4b..5b3886893 100644 --- a/libsqlite3-sys/Cargo.toml +++ b/libsqlite3-sys/Cargo.toml @@ -35,8 +35,8 @@ session = ["preupdate_hook"] bindgen = { version = "0.53", optional = true, default-features = false, features = ["runtime"] } pkg-config = { version = "0.3", optional = true } cc = { version = "1.0", optional = true } -syn = { version = "0.15.34", features = ["extra-traits", "full", "printing"], optional = true } -quote = { version = "0.6.12", optional = true } +syn = { version = "1.0", features = ["extra-traits", "full", "printing"], optional = true } +quote = { version = "1.0", optional = true } which = { version = "2.0.1", optional = true } [target.'cfg(target_env = "msvc")'.build-dependencies] diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index 5b3f5d990..ea728fc4d 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -712,7 +712,7 @@ pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_ro let input_ident = syn::Ident::new(&format!("vararg{}", index + 1), field_ident.span()); let colon = Token![:](field_ident.span()); - input.name = Some((syn::BareFnArgName::Named(input_ident), colon)); + input.name = Some((input_ident, colon)); match var_arg_type.to_owned() { Some(t) => { input.ty = t; @@ -727,7 +727,7 @@ pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_ro let api_fn_input_idents: Vec = (&api_fn_inputs) .into_iter() .map(|input| match &input.name { - Some((syn::BareFnArgName::Named(ident), _)) => ident.to_owned(), + Some((ident, _)) => ident.to_owned(), _ => { panic!("Input has no name {:#?}", input); } From 1e19268d2bdf52f0bf16e118544ba5c3f3019197 Mon Sep 17 00:00:00 2001 From: gwenn Date: Sat, 15 Feb 2020 17:58:29 +0100 Subject: [PATCH 16/61] Fix warning after wrong merge --- src/inner_connection.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/inner_connection.rs b/src/inner_connection.rs index 9aa626561..3feb8aa56 100644 --- a/src/inner_connection.rs +++ b/src/inner_connection.rs @@ -325,6 +325,7 @@ impl Drop for InnerConnection { #[cfg(not(feature = "bundled"))] static SQLITE_VERSION_CHECK: Once = Once::new(); +#[cfg(not(feature = "bundled"))] pub static BYPASS_VERSION_CHECK: AtomicBool = AtomicBool::new(false); #[cfg(not(feature = "bundled"))] From 0b042d061aeec3ca7398be7f8eae343b1778390e Mon Sep 17 00:00:00 2001 From: gwenn Date: Sat, 15 Feb 2020 18:00:47 +0100 Subject: [PATCH 17/61] Run rustfmt manually only while regenerating bindgen files --- .travis.yml | 2 -- appveyor.yml | 1 - libsqlite3-sys/Cargo.toml | 3 +-- libsqlite3-sys/build.rs | 43 ++------------------------------------- libsqlite3-sys/upgrade.sh | 3 ++- 5 files changed, 5 insertions(+), 47 deletions(-) diff --git a/.travis.yml b/.travis.yml index 15fd4d18e..e51abeacd 100644 --- a/.travis.yml +++ b/.travis.yml @@ -7,8 +7,6 @@ rust: - beta - nightly -before_script: rustup component add rustfmt - matrix: fast_finish: true allow_failures: diff --git a/appveyor.yml b/appveyor.yml index db60d3d10..2d88284f2 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -15,7 +15,6 @@ install: - if defined MSYS2_BITS set PATH=%PATH%;C:\msys64\mingw%MSYS2_BITS%\bin - rustc -V - cargo -V - - rustup component add rustfmt # download SQLite dll (useful only when the `bundled` feature is not set) - appveyor-retry appveyor DownloadFile https://sqlite.org/2018/sqlite-dll-win64-x64-3250200.zip -FileName sqlite-dll-win64-x64.zip - if not defined VCPKG_DEFAULT_TRIPLET 7z e sqlite-dll-win64-x64.zip -y > nul diff --git a/libsqlite3-sys/Cargo.toml b/libsqlite3-sys/Cargo.toml index 5b3886893..4759e8fe1 100644 --- a/libsqlite3-sys/Cargo.toml +++ b/libsqlite3-sys/Cargo.toml @@ -15,7 +15,7 @@ categories = ["external-ffi-bindings"] default = ["min_sqlite_version_3_6_8"] bundled = ["cc", "bundled_bindings"] bundled-windows = ["cc", "bundled_bindings"] -buildtime_bindgen = ["bindgen", "pkg-config", "vcpkg", "which"] +buildtime_bindgen = ["bindgen", "pkg-config", "vcpkg"] loadable_extension = ["syn", "quote"] loadable_extension_embedded = ["loadable_extension"] sqlcipher = [] @@ -37,7 +37,6 @@ pkg-config = { version = "0.3", optional = true } cc = { version = "1.0", optional = true } syn = { version = "1.0", features = ["extra-traits", "full", "printing"], optional = true } quote = { version = "1.0", optional = true } -which = { version = "2.0.1", optional = true } [target.'cfg(target_env = "msvc")'.build-dependencies] vcpkg = { version = "0.2", optional = true } diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index ea728fc4d..f28c29eb6 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -414,10 +414,8 @@ mod bindings { use bindgen::callbacks::{IntKind, ParseCallbacks}; use std::fs::OpenOptions; - use std::io::copy; use std::io::Write; use std::path::Path; - use std::process::{Command, Stdio}; #[derive(Debug)] struct SqliteTypeChooser; @@ -438,7 +436,7 @@ mod bindings { let mut bindings = bindgen::builder() .header(header.clone()) .parse_callbacks(Box::new(SqliteTypeChooser)) - .rustfmt_bindings(false); // we'll run rustfmt after (possibly) adding wrappers + .rustfmt_bindings(true); if cfg!(feature = "unlock_notify") { bindings = bindings.clang_arg("-DSQLITE_ENABLE_UNLOCK_NOTIFY"); @@ -581,45 +579,8 @@ pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_ro .open(out_path) .unwrap_or_else(|_| panic!("Could not write to {:?}", out_path)); - // pipe generated bindings through rustfmt - let rustfmt = which::which("rustfmt") - .expect("rustfmt not on PATH") - .to_owned(); - let mut cmd = Command::new(rustfmt); - cmd.stdin(Stdio::piped()).stdout(Stdio::piped()); - let mut rustfmt_child = cmd.spawn().expect("failed to execute rustfmt"); - let mut rustfmt_child_stdin = rustfmt_child.stdin.take().unwrap(); - let mut rustfmt_child_stdout = rustfmt_child.stdout.take().unwrap(); - - // spawn a thread to write output string to rustfmt stdin - let stdin_handle = ::std::thread::spawn(move || { - let _ = rustfmt_child_stdin.write_all(output.as_bytes()); - output - }); - - // read stdout of rustfmt and write it to bindings file at out_path - copy(&mut rustfmt_child_stdout, &mut file) + file.write_all(output.as_bytes()) .unwrap_or_else(|_| panic!("Could not write to {:?}", out_path)); - - let status = rustfmt_child - .wait() - .expect("failed to wait for rustfmt to complete"); - stdin_handle - .join() - .expect("The impossible: writer to rustfmt stdin cannot panic"); - - match status.code() { - Some(0) => {} - Some(2) => { - panic!("rustfmt parsing error"); - } - Some(3) => { - panic!("rustfmt could not format some lines."); - } - _ => { - panic!("Internal rustfmt error"); - } - } } #[cfg(feature = "loadable_extension")] diff --git a/libsqlite3-sys/upgrade.sh b/libsqlite3-sys/upgrade.sh index 41af34b53..4cfd9a061 100755 --- a/libsqlite3-sys/upgrade.sh +++ b/libsqlite3-sys/upgrade.sh @@ -25,7 +25,8 @@ function generate_bindgen_binding() { find $SCRIPT_DIR/../target -type f -name bindgen.rs -exec rm {} \; cargo build --features "$features" --no-default-features find $SCRIPT_DIR/../target -type f -name bindgen.rs -exec cp {} $target_file \; - # TODO rustfmt $target_file + # rerun rustfmt after (possibly) adding wrappers + rustfmt $target_file } generate_bindgen_binding "buildtime_bindgen" $SQLITE3_LIB_DIR/bindgen_bundled_version.rs From 9be9358c1a5bf88b7bcac19a24725b209aa29b85 Mon Sep 17 00:00:00 2001 From: gwenn Date: Sat, 15 Feb 2020 18:03:00 +0100 Subject: [PATCH 18/61] Fix warnings in build script --- libsqlite3-sys/build.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index f28c29eb6..900617c40 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -38,7 +38,6 @@ fn main() { #[cfg(any(feature = "bundled", all(windows, feature = "bundled-windows")))] mod build_bundled { - use super::header_file; use cc; use std::env; use std::path::Path; @@ -51,7 +50,7 @@ mod build_bundled { #[cfg(feature = "buildtime_bindgen")] { - use super::{bindings, HeaderLocation}; + use super::{bindings, header_file, HeaderLocation}; let header = HeaderLocation::FromPath(format!("sqlite3/{}", header_file()).to_owned()); bindings::write_to_out_dir(header, out_path); } @@ -301,6 +300,7 @@ mod build_linked { } } +#[cfg(feature = "loadable_extension")] mod build_loadable_extension { use pkg_config; From 5e20e5d0a66fc721e170867add4f4d088f9c69ea Mon Sep 17 00:00:00 2001 From: gwenn Date: Sat, 15 Feb 2020 18:40:08 +0100 Subject: [PATCH 19/61] Remove code specific to SQLITE_DETERMINISTIC --- libsqlite3-sys/build.rs | 10 ---------- src/functions.rs | 2 +- 2 files changed, 1 insertion(+), 11 deletions(-) diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index 900617c40..4eaf9a6a2 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -562,16 +562,6 @@ pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_ro output.push_str("\n"); } - // rusqlite's functions feature ors in the SQLITE_DETERMINISTIC flag when it - // can. This flag was added in SQLite 3.8.3, but oring it in in prior - // versions of SQLite is harmless. We don't want to not build just - // because this flag is missing (e.g., if we're linking against - // SQLite 3.7.x), so append the flag manually if it isn't present in bindgen's - // output. - if !output.contains("pub const SQLITE_DETERMINISTIC") { - output.push_str("\npub const SQLITE_DETERMINISTIC: i32 = 2048;\n"); - } - let mut file = OpenOptions::new() .write(true) .truncate(true) diff --git a/src/functions.rs b/src/functions.rs index f949559a3..a45032b2e 100644 --- a/src/functions.rs +++ b/src/functions.rs @@ -256,7 +256,7 @@ bitflags::bitflags! { const SQLITE_UTF16LE = ffi::SQLITE_UTF16LE; const SQLITE_UTF16BE = ffi::SQLITE_UTF16BE; const SQLITE_UTF16 = ffi::SQLITE_UTF16; - const SQLITE_DETERMINISTIC = ffi::SQLITE_DETERMINISTIC; + const SQLITE_DETERMINISTIC = 0x0000_0000_0800; // 3.8.3 const SQLITE_DIRECTONLY = 0x0000_0008_0000; // 3.30.0 const SQLITE_SUBTYPE = 0x0000_0010_0000; // 3.30.0 const SQLITE_INNOCUOUS = 0x0000_0020_0000; // 3.31.0 From e4b669c71e5232054c8d33ccc5d617e85c6cc1dd Mon Sep 17 00:00:00 2001 From: gwenn Date: Sat, 15 Feb 2020 18:56:44 +0100 Subject: [PATCH 20/61] Fix build_loadable_extension conditional compilation --- libsqlite3-sys/build.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index 4eaf9a6a2..928fde7aa 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -300,7 +300,7 @@ mod build_linked { } } -#[cfg(feature = "loadable_extension")] +#[cfg(not(any(feature = "bundled", all(windows, feature = "bundled-windows"))))] mod build_loadable_extension { use pkg_config; From df9a1b14e1dd943ed5503826ef18a7a615ddd8b2 Mon Sep 17 00:00:00 2001 From: gwenn Date: Sat, 15 Feb 2020 19:15:32 +0100 Subject: [PATCH 21/61] Remove non_threadsafe feature --- Cargo.toml | 1 - src/inner_connection.rs | 6 ------ 2 files changed, 7 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 0264ffd60..61a1622cb 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -37,7 +37,6 @@ bundled = ["libsqlite3-sys/bundled", "modern_sqlite"] buildtime_bindgen = ["libsqlite3-sys/buildtime_bindgen"] loadable_extension = ["libsqlite3-sys/loadable_extension"] loadable_extension_embedded = ["libsqlite3-sys/loadable_extension_embedded"] -non_threadsafe = [] # sqlite library was built without thread safety (-DSQLITE_THREADSAFE=0) limits = [] hooks = [] i128_blob = ["byteorder"] diff --git a/src/inner_connection.rs b/src/inner_connection.rs index 3feb8aa56..554765cb4 100644 --- a/src/inner_connection.rs +++ b/src/inner_connection.rs @@ -375,7 +375,6 @@ rusqlite was built against SQLite {} but the runtime SQLite version is {}. To fi #[cfg(not(any( feature = "loadable_extension", feature = "loadable_extension_embedded", - feature = "non_threadsafe" )))] static SQLITE_INIT: Once = Once::new(); pub static BYPASS_SQLITE_INIT: AtomicBool = AtomicBool::new(false); @@ -383,13 +382,9 @@ pub static BYPASS_SQLITE_INIT: AtomicBool = AtomicBool::new(false); // threading mode checks are not possible when built as a loadable extension // since the sqlite3_threadsafe, sqlite3_config, and sqlite3_initialize // API calls are not available via the sqlite3_api_routines struct. -// They are also not available when sqlite is built without threadsafe (e.g. -// -DSQLITE_THREADSAFE=0) which is represented here by the "non_threadsafe" -// feature. #[cfg(any( feature = "loadable_extension", feature = "loadable_extension_embedded", - feature = "non_threadsafe" ))] fn ensure_safe_sqlite_threading_mode() -> Result<()> { Ok(()) @@ -398,7 +393,6 @@ fn ensure_safe_sqlite_threading_mode() -> Result<()> { #[cfg(not(any( feature = "loadable_extension", feature = "loadable_extension_embedded", - feature = "non_threadsafe" )))] fn ensure_safe_sqlite_threading_mode() -> Result<()> { // Ensure SQLite was compiled in thredsafe mode. From 14ef2d13fcb850671024f3fac349cf6ef3e4a026 Mon Sep 17 00:00:00 2001 From: gwenn Date: Sun, 16 Feb 2020 09:43:20 +0100 Subject: [PATCH 22/61] Make loadable_extension compatible with bundled* features Like sqlcipher --- libsqlite3-sys/build.rs | 54 ++++++++++------------------------------- 1 file changed, 13 insertions(+), 41 deletions(-) diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index 928fde7aa..63eda04e4 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -15,23 +15,18 @@ fn main() { This can lead to issues if your version of SQLCipher is not up to date!"); } build_linked::main(&out_dir, &out_path) + } else if cfg!(feature = "loadable_extension") { + build_loadable_extension::main(&out_dir, &out_path) } else { // This can't be `cfg!` without always requiring our `mod build_bundled` (and // thus `cc`) #[cfg(any(feature = "bundled", all(windows, feature = "bundled-windows")))] { - if cfg!(feature = "loadable_extension") { - panic!("Building a loadable extension bundled is not supported"); - } build_bundled::main(&out_dir, &out_path) } #[cfg(not(any(feature = "bundled", all(windows, feature = "bundled-windows"))))] { - if cfg!(feature = "loadable_extension") { - build_loadable_extension::main(&out_dir, &out_path) - } else { - build_linked::main(&out_dir, &out_path) - } + build_linked::main(&out_dir, &out_path) } } } @@ -48,18 +43,9 @@ mod build_bundled { panic!("Builds with bundled SQLCipher are not supported"); } - #[cfg(feature = "buildtime_bindgen")] - { - use super::{bindings, header_file, HeaderLocation}; - let header = HeaderLocation::FromPath(format!("sqlite3/{}", header_file()).to_owned()); - bindings::write_to_out_dir(header, out_path); - } - #[cfg(not(feature = "buildtime_bindgen"))] - { - use std::fs; - fs::copy("sqlite3/bindgen_bundled_version.rs", out_path) - .expect("Could not copy bindings to output directory"); - } + use super::{bindings, header_file, HeaderLocation}; + let header = HeaderLocation::FromPath(format!("sqlite3/{}", header_file()).to_owned()); + bindings::write_to_out_dir(header, out_path); let mut cfg = cc::Build::new(); cfg.file("sqlite3/sqlite3.c") @@ -180,32 +166,13 @@ impl From for String { mod build_linked { use pkg_config; - #[cfg(all(feature = "vcpkg", target_env = "msvc"))] - extern crate vcpkg; - use super::{bindings, env_prefix, header_file, HeaderLocation}; use std::env; use std::path::Path; pub fn main(_out_dir: &str, out_path: &Path) { let header = find_sqlite(); - if cfg!(any( - feature = "bundled_bindings", - feature = "bundled", - all(windows, feature = "bundled-windows") - )) && !cfg!(feature = "buildtime_bindgen") - { - // Generally means the `bundled_bindings` feature is enabled - // (there's also an edge case where we get here involving - // sqlcipher). In either case most users are better off with turning - // on buildtime_bindgen instead, but this is still supported as we - // have runtime version checks and there are good reasons to not - // want to run bindgen. - std::fs::copy("sqlite3/bindgen_bundled_version.rs", out_path) - .expect("Could not copy bindings to output directory"); - } else { - bindings::write_to_out_dir(header, out_path); - } + bindings::write_to_out_dir(header, out_path); } fn find_link_mode() -> &'static str { @@ -300,7 +267,6 @@ mod build_linked { } } -#[cfg(not(any(feature = "bundled", all(windows, feature = "bundled-windows"))))] mod build_loadable_extension { use pkg_config; @@ -381,6 +347,12 @@ mod bindings { "bindgen-bindings/bindgen_3.6.8", #[cfg(feature = "min_sqlite_version_3_7_16")] "bindgen-bindings/bindgen_3.7.16", + #[cfg(any( + feature = "bundled_bindings", + feature = "bundled", + all(windows, feature = "bundled-windows") + ))] + "sqlite3/bindgen_bundled_version", ]; pub fn write_to_out_dir(_header: HeaderLocation, out_path: &Path) { From 347c9ff9570bfefa64b92a9de8a7db8ea2be76ba Mon Sep 17 00:00:00 2001 From: gwenn Date: Sun, 16 Feb 2020 10:20:37 +0100 Subject: [PATCH 23/61] Fix clippy warnings --- libsqlite3-sys/build.rs | 28 +++++++++------------------- src/lib.rs | 4 ++++ 2 files changed, 13 insertions(+), 19 deletions(-) diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index 63eda04e4..4eeb0494a 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -33,7 +33,6 @@ fn main() { #[cfg(any(feature = "bundled", all(windows, feature = "bundled-windows")))] mod build_bundled { - use cc; use std::env; use std::path::Path; @@ -44,7 +43,7 @@ mod build_bundled { } use super::{bindings, header_file, HeaderLocation}; - let header = HeaderLocation::FromPath(format!("sqlite3/{}", header_file()).to_owned()); + let header = HeaderLocation::FromPath(format!("sqlite3/{}", header_file())); bindings::write_to_out_dir(header, out_path); let mut cfg = cc::Build::new(); @@ -164,8 +163,6 @@ impl From for String { } mod build_linked { - use pkg_config; - use super::{bindings, env_prefix, header_file, HeaderLocation}; use std::env; use std::path::Path; @@ -268,8 +265,6 @@ mod build_linked { } mod build_loadable_extension { - use pkg_config; - use super::{bindings, env_prefix, header_file, HeaderLocation}; use std::env; use std::path::Path; @@ -343,7 +338,7 @@ mod bindings { use std::fs; use std::path::Path; - static PREBUILT_BINDGEN_PATHS: &'static [&'static str] = &[ + static PREBUILT_BINDGEN_PATHS: &[&str] = &[ "bindgen-bindings/bindgen_3.6.8", #[cfg(feature = "min_sqlite_version_3_7_16")] "bindgen-bindings/bindgen_3.7.16", @@ -361,7 +356,7 @@ mod bindings { PREBUILT_BINDGEN_PATHS[PREBUILT_BINDGEN_PATHS.len() - 1], prebuilt_bindgen_ext() ); - fs::copy(in_path.to_owned(), out_path).expect(&format!( + fs::copy(in_path.to_owned(), out_path).unwrap_or_else(|_| panic!( "Could not copy bindings to output directory from {}", in_path )); @@ -380,8 +375,6 @@ mod bindings { #[cfg(feature = "buildtime_bindgen")] mod bindings { - use bindgen; - use super::HeaderLocation; use bindgen::callbacks::{IntKind, ParseCallbacks}; @@ -446,7 +439,7 @@ mod bindings { .unwrap_or_else(|_| panic!("could not run bindgen on header {}", header)) .write(Box::new(&mut output)) .expect("could not write output of bindgen"); - let mut output = String::from_utf8(output).expect("bindgen output was not UTF-8?!"); + let output = String::from_utf8(output).expect("bindgen output was not UTF-8?!"); // Get the list of API functions supported by sqlite3_api_routines, // set the corresponding sqlite3 api routine to be blacklisted in the @@ -556,7 +549,7 @@ pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_ro } } } - return None; + None } #[cfg(feature = "loadable_extension")] @@ -621,7 +614,7 @@ pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_ro // transparently wrap variadic api functions. // generate specific set of args in place of // variadic for each function we care about. - let var_arg_types: Vec> = match api_fn_name.as_ref() { + let var_arg_types: Vec> = match api_fn_name { "sqlite3_db_config" => { let mut_int_type: syn::TypeReference = syn::parse2(quote!(&mut i32)) .expect("failed to parse mutable integer reference"); @@ -636,12 +629,9 @@ pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_ro syn::Ident::new(&format!("vararg{}", index + 1), field_ident.span()); let colon = Token![:](field_ident.span()); input.name = Some((input_ident, colon)); - match var_arg_type.to_owned() { - Some(t) => { - input.ty = t; - } - None => {} - }; + if let Some(t) = var_arg_type.to_owned() { + input.ty = t; + } api_fn_inputs.push(input); } } diff --git a/src/lib.rs b/src/lib.rs index 80de49b0a..9574aa14f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -749,6 +749,10 @@ impl Connection { /// /// The underlying SQLite database connection handle will not be closed when /// the returned connection is dropped/closed. + /// + /// # Safety + /// + /// This function is unsafe because improper use may impact the Connection. pub unsafe fn from_handle(db: *mut ffi::sqlite3) -> Result { let db_path = db_filename(db); let db = InnerConnection::new(db, false); From 112b0614b66c913ca181a8f6aac0e6ecc751b785 Mon Sep 17 00:00:00 2001 From: gwenn Date: Sun, 16 Feb 2020 10:36:58 +0100 Subject: [PATCH 24/61] Fix compilation error with loadable_extension feature --- libsqlite3-sys/build.rs | 10 ++++++---- src/lib.rs | 4 ++++ src/raw_statement.rs | 8 ++++++++ src/statement.rs | 8 ++++++++ tests/deny_single_threaded_sqlite_config.rs | 10 +++++++--- 5 files changed, 33 insertions(+), 7 deletions(-) diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index 4eeb0494a..74f57e66d 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -356,10 +356,12 @@ mod bindings { PREBUILT_BINDGEN_PATHS[PREBUILT_BINDGEN_PATHS.len() - 1], prebuilt_bindgen_ext() ); - fs::copy(in_path.to_owned(), out_path).unwrap_or_else(|_| panic!( - "Could not copy bindings to output directory from {}", - in_path - )); + fs::copy(in_path.to_owned(), out_path).unwrap_or_else(|_| { + panic!( + "Could not copy bindings to output directory from {}", + in_path + ) + }); } fn prebuilt_bindgen_ext() -> &'static str { diff --git a/src/lib.rs b/src/lib.rs index 9574aa14f..21c3e8b95 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -101,6 +101,10 @@ mod cache; #[cfg(feature = "collation")] mod collation; mod column; +#[cfg(not(any( + feature = "loadable_extension", + feature = "loadable_extension_embedded" +)))] pub mod config; #[cfg(any(feature = "functions", feature = "vtab"))] mod context; diff --git a/src/raw_statement.rs b/src/raw_statement.rs index 8d943baa5..33d481466 100644 --- a/src/raw_statement.rs +++ b/src/raw_statement.rs @@ -1,5 +1,9 @@ use super::ffi; use super::unlock_notify; +#[cfg(not(any( + feature = "loadable_extension", + feature = "loadable_extension_embedded" +)))] use super::StatementStatus; use std::ffi::CStr; use std::os::raw::c_int; @@ -133,6 +137,10 @@ impl RawStatement { } } + #[cfg(not(any( + feature = "loadable_extension", + feature = "loadable_extension_embedded" + )))] pub fn get_status(&self, status: StatementStatus, reset: bool) -> i32 { assert!(!self.0.is_null()); unsafe { ffi::sqlite3_stmt_status(self.0, status as i32, reset as i32) } diff --git a/src/statement.rs b/src/statement.rs index e421832e8..e74598136 100644 --- a/src/statement.rs +++ b/src/statement.rs @@ -589,12 +589,20 @@ impl Statement<'_> { } /// Get the value for one of the status counters for this statement. + #[cfg(not(any( + feature = "loadable_extension", + feature = "loadable_extension_embedded" + )))] pub fn get_status(&self, status: StatementStatus) -> i32 { self.stmt.get_status(status, false) } /// Reset the value of one of the status counters for this statement, /// returning the value it had before resetting. + #[cfg(not(any( + feature = "loadable_extension", + feature = "loadable_extension_embedded" + )))] pub fn reset_status(&self, status: StatementStatus) -> i32 { self.stmt.get_status(status, true) } diff --git a/tests/deny_single_threaded_sqlite_config.rs b/tests/deny_single_threaded_sqlite_config.rs index f6afdd51c..cabcff7fc 100644 --- a/tests/deny_single_threaded_sqlite_config.rs +++ b/tests/deny_single_threaded_sqlite_config.rs @@ -1,12 +1,16 @@ //! Ensure we reject connections when SQLite is in single-threaded mode, as it //! would violate safety if multiple Rust threads tried to use connections. -use rusqlite::ffi; -use rusqlite::Connection; - +#[cfg(not(any( + feature = "loadable_extension", + feature = "loadable_extension_embedded" +)))] #[test] #[should_panic] fn test_error_when_singlethread_mode() { + use rusqlite::ffi; + use rusqlite::Connection; + // put SQLite into single-threaded mode unsafe { if ffi::sqlite3_config(ffi::SQLITE_CONFIG_SINGLETHREAD) != ffi::SQLITE_OK { From 5181ccab79a8d81ce83fbeb60a9a0f8a03fe7aeb Mon Sep 17 00:00:00 2001 From: gwenn Date: Sun, 16 Feb 2020 10:48:01 +0100 Subject: [PATCH 25/61] Revert output mutability --- libsqlite3-sys/build.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index 74f57e66d..1bf740ab9 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -441,7 +441,7 @@ mod bindings { .unwrap_or_else(|_| panic!("could not run bindgen on header {}", header)) .write(Box::new(&mut output)) .expect("could not write output of bindgen"); - let output = String::from_utf8(output).expect("bindgen output was not UTF-8?!"); + let mut output = String::from_utf8(output).expect("bindgen output was not UTF-8?!"); // Get the list of API functions supported by sqlite3_api_routines, // set the corresponding sqlite3 api routine to be blacklisted in the From ffbf6b54efbd3e0b5f58fd7e78296ec46ebd8005 Mon Sep 17 00:00:00 2001 From: gwenn Date: Sun, 16 Feb 2020 11:18:12 +0100 Subject: [PATCH 26/61] Fix warnings --- src/inner_connection.rs | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/src/inner_connection.rs b/src/inner_connection.rs index 554765cb4..8d9303c6e 100644 --- a/src/inner_connection.rs +++ b/src/inner_connection.rs @@ -5,8 +5,8 @@ use std::os::raw::{c_char, c_int}; use std::path::Path; use std::ptr; use std::str; -use std::sync::atomic::{AtomicBool, Ordering}; -use std::sync::{Arc, Mutex, Once}; +use std::sync::atomic::AtomicBool; +use std::sync::{Arc, Mutex}; use super::ffi; use super::{str_for_sqlite, str_to_cstring}; @@ -15,7 +15,6 @@ use crate::error::{error_from_handle, error_from_sqlite_code, Error}; use crate::raw_statement::RawStatement; use crate::statement::Statement; use crate::unlock_notify; -use crate::version::version_number; pub struct InnerConnection { pub db: *mut ffi::sqlite3, @@ -324,13 +323,14 @@ impl Drop for InnerConnection { } #[cfg(not(feature = "bundled"))] -static SQLITE_VERSION_CHECK: Once = Once::new(); +static SQLITE_VERSION_CHECK: std::sync::Once = std::sync::Once::new(); #[cfg(not(feature = "bundled"))] pub static BYPASS_VERSION_CHECK: AtomicBool = AtomicBool::new(false); #[cfg(not(feature = "bundled"))] fn ensure_valid_sqlite_version() { - use crate::version::version; + use crate::version::{version, version_number}; + use std::sync::atomic::Ordering; SQLITE_VERSION_CHECK.call_once(|| { let version_number = version_number(); @@ -376,7 +376,7 @@ rusqlite was built against SQLite {} but the runtime SQLite version is {}. To fi feature = "loadable_extension", feature = "loadable_extension_embedded", )))] -static SQLITE_INIT: Once = Once::new(); +static SQLITE_INIT: std::sync::Once = std::sync::Once::new(); pub static BYPASS_SQLITE_INIT: AtomicBool = AtomicBool::new(false); // threading mode checks are not possible when built as a loadable extension @@ -395,6 +395,9 @@ fn ensure_safe_sqlite_threading_mode() -> Result<()> { feature = "loadable_extension_embedded", )))] fn ensure_safe_sqlite_threading_mode() -> Result<()> { + use crate::version::version_number; + use std::sync::atomic::Ordering; + // Ensure SQLite was compiled in thredsafe mode. if unsafe { ffi::sqlite3_threadsafe() == 0 } { return Err(Error::SqliteSingleThreadedMode); From 0f6ad74d72a184f4428ed6f25fd25dbdc5a1083c Mon Sep 17 00:00:00 2001 From: gwenn Date: Sun, 16 Feb 2020 11:18:35 +0100 Subject: [PATCH 27/61] Check loadable_extension build --- .travis.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.travis.yml b/.travis.yml index e51abeacd..7305f14d4 100644 --- a/.travis.yml +++ b/.travis.yml @@ -27,6 +27,7 @@ script: - cargo build --features bundled - cargo build --features sqlcipher - cargo build --features "bundled sqlcipher" + - cargo build --features "loadable_extension backup blob collation functions limits hooks unlock_notify vtab window bundled" - cargo test - cargo test --features "backup blob extra_check" - cargo test --features "collation functions" From 39ac4430b3b6478bad356f7de7b78f5e9438bebe Mon Sep 17 00:00:00 2001 From: "Joshua C. Randall" Date: Sat, 22 Feb 2020 12:24:21 +0000 Subject: [PATCH 28/61] eliminate -ext-embed versions of bindgen-bindings --- .../bindgen_3.6.8-ext-embed.rs | 6833 ---------- .../bindgen-bindings/bindgen_3.6.8-ext.rs | 8 +- .../bindgen_3.7.16-ext-embed.rs | 8584 ------------ .../bindgen-bindings/bindgen_3.7.16-ext.rs | 8 +- libsqlite3-sys/build.rs | 52 +- .../bindgen_bundled_version-ext-embed.rs | 11383 ---------------- .../sqlite3/bindgen_bundled_version-ext.rs | 6 - libsqlite3-sys/src/lib.rs | 17 + libsqlite3-sys/upgrade.sh | 1 - src/error.rs | 4 + 10 files changed, 40 insertions(+), 26856 deletions(-) delete mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext-embed.rs delete mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext-embed.rs delete mode 100644 libsqlite3-sys/sqlite3/bindgen_bundled_version-ext-embed.rs diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext-embed.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext-embed.rs deleted file mode 100644 index 9c4d18f45..000000000 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext-embed.rs +++ /dev/null @@ -1,6833 +0,0 @@ -/* automatically generated by rust-bindgen */ - -pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 6usize] = b"3.6.8\0"; -pub const SQLITE_VERSION_NUMBER: i32 = 3006008; -pub const SQLITE_OK: i32 = 0; -pub const SQLITE_ERROR: i32 = 1; -pub const SQLITE_INTERNAL: i32 = 2; -pub const SQLITE_PERM: i32 = 3; -pub const SQLITE_ABORT: i32 = 4; -pub const SQLITE_BUSY: i32 = 5; -pub const SQLITE_LOCKED: i32 = 6; -pub const SQLITE_NOMEM: i32 = 7; -pub const SQLITE_READONLY: i32 = 8; -pub const SQLITE_INTERRUPT: i32 = 9; -pub const SQLITE_IOERR: i32 = 10; -pub const SQLITE_CORRUPT: i32 = 11; -pub const SQLITE_NOTFOUND: i32 = 12; -pub const SQLITE_FULL: i32 = 13; -pub const SQLITE_CANTOPEN: i32 = 14; -pub const SQLITE_PROTOCOL: i32 = 15; -pub const SQLITE_EMPTY: i32 = 16; -pub const SQLITE_SCHEMA: i32 = 17; -pub const SQLITE_TOOBIG: i32 = 18; -pub const SQLITE_CONSTRAINT: i32 = 19; -pub const SQLITE_MISMATCH: i32 = 20; -pub const SQLITE_MISUSE: i32 = 21; -pub const SQLITE_NOLFS: i32 = 22; -pub const SQLITE_AUTH: i32 = 23; -pub const SQLITE_FORMAT: i32 = 24; -pub const SQLITE_RANGE: i32 = 25; -pub const SQLITE_NOTADB: i32 = 26; -pub const SQLITE_ROW: i32 = 100; -pub const SQLITE_DONE: i32 = 101; -pub const SQLITE_IOERR_READ: i32 = 266; -pub const SQLITE_IOERR_SHORT_READ: i32 = 522; -pub const SQLITE_IOERR_WRITE: i32 = 778; -pub const SQLITE_IOERR_FSYNC: i32 = 1034; -pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; -pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; -pub const SQLITE_IOERR_FSTAT: i32 = 1802; -pub const SQLITE_IOERR_UNLOCK: i32 = 2058; -pub const SQLITE_IOERR_RDLOCK: i32 = 2314; -pub const SQLITE_IOERR_DELETE: i32 = 2570; -pub const SQLITE_IOERR_BLOCKED: i32 = 2826; -pub const SQLITE_IOERR_NOMEM: i32 = 3082; -pub const SQLITE_IOERR_ACCESS: i32 = 3338; -pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; -pub const SQLITE_IOERR_LOCK: i32 = 3850; -pub const SQLITE_IOERR_CLOSE: i32 = 4106; -pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; -pub const SQLITE_OPEN_READONLY: i32 = 1; -pub const SQLITE_OPEN_READWRITE: i32 = 2; -pub const SQLITE_OPEN_CREATE: i32 = 4; -pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; -pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; -pub const SQLITE_OPEN_MAIN_DB: i32 = 256; -pub const SQLITE_OPEN_TEMP_DB: i32 = 512; -pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; -pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; -pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; -pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; -pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; -pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; -pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; -pub const SQLITE_IOCAP_ATOMIC: i32 = 1; -pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; -pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; -pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; -pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; -pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; -pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; -pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; -pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; -pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; -pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; -pub const SQLITE_LOCK_NONE: i32 = 0; -pub const SQLITE_LOCK_SHARED: i32 = 1; -pub const SQLITE_LOCK_RESERVED: i32 = 2; -pub const SQLITE_LOCK_PENDING: i32 = 3; -pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; -pub const SQLITE_SYNC_NORMAL: i32 = 2; -pub const SQLITE_SYNC_FULL: i32 = 3; -pub const SQLITE_SYNC_DATAONLY: i32 = 16; -pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; -pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_LAST_ERRNO: i32 = 4; -pub const SQLITE_ACCESS_EXISTS: i32 = 0; -pub const SQLITE_ACCESS_READWRITE: i32 = 1; -pub const SQLITE_ACCESS_READ: i32 = 2; -pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; -pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; -pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; -pub const SQLITE_CONFIG_MALLOC: i32 = 4; -pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; -pub const SQLITE_CONFIG_SCRATCH: i32 = 6; -pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; -pub const SQLITE_CONFIG_HEAP: i32 = 8; -pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; -pub const SQLITE_CONFIG_MUTEX: i32 = 10; -pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; -pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; -pub const SQLITE_CONFIG_PCACHE: i32 = 14; -pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; -pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; -pub const SQLITE_DENY: i32 = 1; -pub const SQLITE_IGNORE: i32 = 2; -pub const SQLITE_CREATE_INDEX: i32 = 1; -pub const SQLITE_CREATE_TABLE: i32 = 2; -pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; -pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; -pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; -pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; -pub const SQLITE_CREATE_TRIGGER: i32 = 7; -pub const SQLITE_CREATE_VIEW: i32 = 8; -pub const SQLITE_DELETE: i32 = 9; -pub const SQLITE_DROP_INDEX: i32 = 10; -pub const SQLITE_DROP_TABLE: i32 = 11; -pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; -pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; -pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; -pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; -pub const SQLITE_DROP_TRIGGER: i32 = 16; -pub const SQLITE_DROP_VIEW: i32 = 17; -pub const SQLITE_INSERT: i32 = 18; -pub const SQLITE_PRAGMA: i32 = 19; -pub const SQLITE_READ: i32 = 20; -pub const SQLITE_SELECT: i32 = 21; -pub const SQLITE_TRANSACTION: i32 = 22; -pub const SQLITE_UPDATE: i32 = 23; -pub const SQLITE_ATTACH: i32 = 24; -pub const SQLITE_DETACH: i32 = 25; -pub const SQLITE_ALTER_TABLE: i32 = 26; -pub const SQLITE_REINDEX: i32 = 27; -pub const SQLITE_ANALYZE: i32 = 28; -pub const SQLITE_CREATE_VTABLE: i32 = 29; -pub const SQLITE_DROP_VTABLE: i32 = 30; -pub const SQLITE_FUNCTION: i32 = 31; -pub const SQLITE_SAVEPOINT: i32 = 32; -pub const SQLITE_COPY: i32 = 0; -pub const SQLITE_LIMIT_LENGTH: i32 = 0; -pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; -pub const SQLITE_LIMIT_COLUMN: i32 = 2; -pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; -pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; -pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; -pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; -pub const SQLITE_LIMIT_ATTACHED: i32 = 7; -pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; -pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; -pub const SQLITE_INTEGER: i32 = 1; -pub const SQLITE_FLOAT: i32 = 2; -pub const SQLITE_BLOB: i32 = 4; -pub const SQLITE_NULL: i32 = 5; -pub const SQLITE_TEXT: i32 = 3; -pub const SQLITE3_TEXT: i32 = 3; -pub const SQLITE_UTF8: i32 = 1; -pub const SQLITE_UTF16LE: i32 = 2; -pub const SQLITE_UTF16BE: i32 = 3; -pub const SQLITE_UTF16: i32 = 4; -pub const SQLITE_ANY: i32 = 5; -pub const SQLITE_UTF16_ALIGNED: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; -pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; -pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; -pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; -pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; -pub const SQLITE_MUTEX_FAST: i32 = 0; -pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; -pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; -pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; -pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; -pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; -pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; -pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; -pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; -pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; -pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; -pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; -pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; -pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; -pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; -pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; -pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; -pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; -pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; -pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; -pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; -pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; -pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; -pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; -pub const SQLITE_STMTSTATUS_SORT: i32 = 2; -pub type va_list = __builtin_va_list; -pub type __gnuc_va_list = __builtin_va_list; -extern "C" { - #[link_name = "\u{1}sqlite3_version"] - pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3 { - _unused: [u8; 0], -} -pub type sqlite_int64 = ::std::os::raw::c_longlong; -pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; -pub type sqlite3_int64 = sqlite_int64; -pub type sqlite3_uint64 = sqlite_uint64; -pub type sqlite3_callback = ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_file { - pub pMethods: *const sqlite3_io_methods, -} -#[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_file)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_file)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_file), - "::", - stringify!(pMethods) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_io_methods { - pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xRead: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *mut ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xWrite: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *const ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pSize: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xUnlock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCheckReservedLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileControl: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - op: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xSectorSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xDeviceCharacteristics: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_io_methods() { - assert_eq!( - ::std::mem::size_of::(), - 104usize, - concat!("Size of: ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xRead) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xWrite) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnlock) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xCheckReservedLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileControl) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSectorSize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ - as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xDeviceCharacteristics) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vfs { - pub iVersion: ::std::os::raw::c_int, - pub szOsFile: ::std::os::raw::c_int, - pub mxPathname: ::std::os::raw::c_int, - pub pNext: *mut sqlite3_vfs, - pub zName: *const ::std::os::raw::c_char, - pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - pOutFlags: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - syncDir: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xAccess: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - flags: ::std::os::raw::c_int, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFullPathname: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - nOut: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xDlOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zFilename: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void, - >, - pub xDlError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zErrMsg: *mut ::std::os::raw::c_char, - ), - >, - pub xDlSym: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ) -> ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ), - >, - >, - pub xDlClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), - >, - pub xRandomness: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSleep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - microseconds: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTime: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, - >, - pub xGetLastError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!( - ::std::mem::size_of::(), - 136usize, - concat!("Size of: ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(szOsFile) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(mxPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(zName) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pAppData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xAccess) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xFullPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlSym) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xRandomness) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSleep) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTime) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetLastError) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xRoundup: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub pAppData: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!( - ::std::mem::size_of::(), - 64usize, - concat!("Size of: ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xMalloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xFree) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRealloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRoundup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(pAppData) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Mem { - _unused: [u8; 0], -} -pub type sqlite3_value = Mem; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_context { - _unused: [u8; 0], -} -pub type sqlite3_destructor_type = - ::std::option::Option; -extern "C" { - #[link_name = "\u{1}sqlite3_temp_directory"] - pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xConnect: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xBestIndex: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: *mut sqlite3_index_info, - ) -> ::std::os::raw::c_int, - >, - pub xDisconnect: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xDestroy: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - ppCursor: *mut *mut sqlite3_vtab_cursor, - ) -> ::std::os::raw::c_int, - >, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xFilter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - idxNum: ::std::os::raw::c_int, - idxStr: *const ::std::os::raw::c_char, - argc: ::std::os::raw::c_int, - argv: *mut *mut sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub xNext: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xEof: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - arg2: *mut sqlite3_context, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - pRowid: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xUpdate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - arg4: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xBegin: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xCommit: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xRollback: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xFindFunction: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - nArg: ::std::os::raw::c_int, - zName: *const ::std::os::raw::c_char, - pxFunc: *mut ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - ppArg: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xRename: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - zNew: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!( - ::std::mem::size_of::(), - 160usize, - concat!("Size of: ", stringify!(sqlite3_module)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_module)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xConnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBestIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDisconnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFilter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xEof) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xColumn) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xUpdate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBegin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCommit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollback) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFindFunction) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRename) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info { - pub nConstraint: ::std::os::raw::c_int, - pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, - pub nOrderBy: ::std::os::raw::c_int, - pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, - pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, - pub idxNum: ::std::os::raw::c_int, - pub idxStr: *mut ::std::os::raw::c_char, - pub needToFreeIdxStr: ::std::os::raw::c_int, - pub orderByConsumed: ::std::os::raw::c_int, - pub estimatedCost: f64, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint { - pub iColumn: ::std::os::raw::c_int, - pub op: ::std::os::raw::c_uchar, - pub usable: ::std::os::raw::c_uchar, - pub iTermOffset: ::std::os::raw::c_int, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).op as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(op) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).usable - as *const _ as usize - }, - 5usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(usable) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iTermOffset - as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iTermOffset) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_orderby { - pub iColumn: ::std::os::raw::c_int, - pub desc: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).desc as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(desc) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint_usage { - pub argvIndex: ::std::os::raw::c_int, - pub omit: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).argvIndex - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(argvIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).omit - as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(omit) - ) - ); -} -#[test] -fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nOrderBy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aOrderBy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraintUsage) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxNum) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(needToFreeIdxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(orderByConsumed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedCost as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedCost) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(pModule) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(nRef) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(zErrMsg) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab_cursor { - pub pVtab: *mut sqlite3_vtab, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab_cursor), - "::", - stringify!(pVtab) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexNotheld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexInit as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnd) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexAlloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexFree as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexFree) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexTry) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexLeave) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexHeld) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexNotheld) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods { - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!( - ::std::mem::size_of::(), - 88usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xDestroy) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_api_routines { - pub aggregate_context: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub aggregate_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, - >, - pub bind_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_double: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, - ) -> ::std::os::raw::c_int, - >, - pub bind_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_int64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, - ) -> ::std::os::raw::c_int, - >, - pub bind_null: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub bind_parameter_index: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub bind_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub busy_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub busy_timeout: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub changes: - ::std::option::Option ::std::os::raw::c_int>, - pub close: - ::std::option::Option ::std::os::raw::c_int>, - pub collation_needed: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub collation_needed16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub column_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_bytes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_bytes16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub column_database_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_database_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_decltype: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_decltype16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_double: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, - >, - pub column_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_int64: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, - >, - pub column_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_origin_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_origin_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_table_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_table_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_uchar, - >, - pub column_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_type: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *mut sqlite3_value, - >, - pub commit_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub complete: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, - pub complete16: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub create_collation: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_collation16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_function16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_module: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub data_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub db_handle: - ::std::option::Option *mut sqlite3>, - pub declare_vtab: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub enable_shared_cache: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub errcode: - ::std::option::Option ::std::os::raw::c_int>, - pub errmsg: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, - >, - pub errmsg16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, - >, - pub exec: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub expired: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub finalize: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub free: ::std::option::Option, - pub free_table: - ::std::option::Option, - pub get_autocommit: - ::std::option::Option ::std::os::raw::c_int>, - pub get_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub get_table: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub global_recover: ::std::option::Option ::std::os::raw::c_int>, - pub interruptx: ::std::option::Option, - pub last_insert_rowid: - ::std::option::Option sqlite_int64>, - pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, - pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, - pub malloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub mprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub open16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub prepare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub profile: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub progress_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, - ), - >, - pub realloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub reset: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub result_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_double: - ::std::option::Option, - pub result_error: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_error16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_int64: - ::std::option::Option, - pub result_null: ::std::option::Option, - pub result_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16be: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16le: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_value: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), - >, - pub rollback_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub set_authorizer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub set_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, - ), - >, - pub snprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub step: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub table_column_metadata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub thread_cleanup: ::std::option::Option, - pub total_changes: - ::std::option::Option ::std::os::raw::c_int>, - pub trace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub transfer_bindings: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, - ) -> ::std::os::raw::c_int, - >, - pub update_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub user_data: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, - >, - pub value_blob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_bytes16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_double: ::std::option::Option f64>, - pub value_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_int64: - ::std::option::Option sqlite_int64>, - pub value_numeric_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_text: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, - >, - pub value_text16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16be: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16le: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub vmprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char, - >, - pub overload_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub prepare_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub clear_bindings: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub create_module_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_zeroblob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_close: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, - ) -> ::std::os::raw::c_int, - >, - pub blob_read: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_write: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub create_collation_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub file_control: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub memory_highwater: - ::std::option::Option sqlite3_int64>, - pub memory_used: ::std::option::Option sqlite3_int64>, - pub mutex_alloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub mutex_enter: ::std::option::Option, - pub mutex_free: ::std::option::Option, - pub mutex_leave: ::std::option::Option, - pub mutex_try: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub open_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub release_memory: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub result_error_nomem: ::std::option::Option, - pub result_error_toobig: - ::std::option::Option, - pub sleep: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub soft_heap_limit: ::std::option::Option, - pub vfs_find: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, - >, - pub vfs_register: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub vfs_unregister: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, - >, - pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, - pub result_zeroblob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_error_code: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub test_control: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, - >, - pub randomness: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), - >, - pub context_db_handle: - ::std::option::Option *mut sqlite3>, - pub extended_result_codes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub limit: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub next_stmt: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, - >, - pub sql: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, - >, - pub status: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_api_routines() { - assert_eq!( - ::std::mem::size_of::(), - 1240usize, - concat!("Size of: ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_context as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_context) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_count as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_double as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_count as *const _ - as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_index as *const _ - as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_index) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_name as *const _ - as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_text16 as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_handler as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_handler) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_timeout as *const _ as usize - }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_timeout) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(close) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed as *const _ as usize - }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_blob as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes as *const _ as usize - }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize - }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_count as *const _ as usize - }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name as *const _ - as usize - }, - 184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name16 as *const _ - as usize - }, - 192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype as *const _ as usize - }, - 200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize - }, - 208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_double as *const _ as usize - }, - 216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, - 224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_int64 as *const _ as usize - }, - 232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name as *const _ as usize - }, - 240usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name16 as *const _ as usize - }, - 248usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name as *const _ as usize - }, - 256usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name16 as *const _ - as usize - }, - 264usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name as *const _ as usize - }, - 272usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name16 as *const _ - as usize - }, - 280usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text as *const _ as usize - }, - 288usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text16 as *const _ as usize - }, - 296usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_type as *const _ as usize - }, - 304usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_type) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_value as *const _ as usize - }, - 312usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).commit_hook as *const _ as usize - }, - 320usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(commit_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, - 328usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, - 336usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation as *const _ as usize - }, - 344usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation16 as *const _ as usize - }, - 352usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function as *const _ as usize - }, - 360usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function16 as *const _ as usize - }, - 368usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module as *const _ as usize - }, - 376usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, - 384usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(data_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, - 392usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).declare_vtab as *const _ as usize - }, - 400usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(declare_vtab) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).enable_shared_cache as *const _ - as usize - }, - 408usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(enable_shared_cache) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, - 416usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, - 424usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, - 432usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, - 440usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(exec) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, - 448usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(expired) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, - 456usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(finalize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, - 464usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, - 472usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_autocommit as *const _ as usize - }, - 480usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_autocommit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_auxdata as *const _ as usize - }, - 488usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, - 496usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).global_recover as *const _ as usize - }, - 504usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(global_recover) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, - 512usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(interruptx) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize - }, - 520usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(last_insert_rowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, - 528usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).libversion_number as *const _ as usize - }, - 536usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion_number) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, - 544usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(malloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, - 552usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, - 560usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, - 568usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, - 576usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, - 584usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, - 592usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(profile) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).progress_handler as *const _ as usize - }, - 600usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(progress_handler) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, - 608usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(realloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, - 616usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(reset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_blob as *const _ as usize - }, - 624usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_double as *const _ as usize - }, - 632usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_double) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error as *const _ as usize - }, - 640usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error16 as *const _ as usize - }, - 648usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, - 656usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_int64 as *const _ as usize - }, - 664usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_null as *const _ as usize - }, - 672usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text as *const _ as usize - }, - 680usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16 as *const _ as usize - }, - 688usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16be as *const _ as usize - }, - 696usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16le as *const _ as usize - }, - 704usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16le) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_value as *const _ as usize - }, - 712usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rollback_hook as *const _ as usize - }, - 720usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(rollback_hook) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_authorizer as *const _ as usize - }, - 728usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_authorizer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_auxdata as *const _ as usize - }, - 736usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).snprintf as *const _ as usize }, - 744usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(snprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, - 752usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(step) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).table_column_metadata as *const _ - as usize - }, - 760usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(table_column_metadata) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize - }, - 768usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(thread_cleanup) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).total_changes as *const _ as usize - }, - 776usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(total_changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, - 784usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(trace) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize - }, - 792usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(transfer_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).update_hook as *const _ as usize - }, - 800usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(update_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, - 808usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(user_data) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, - 816usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes as *const _ as usize - }, - 824usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize - }, - 832usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_double as *const _ as usize - }, - 840usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, - 848usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_int64 as *const _ as usize - }, - 856usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize - }, - 864usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_numeric_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, - 872usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16 as *const _ as usize - }, - 880usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16be as *const _ as usize - }, - 888usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16le as *const _ as usize - }, - 896usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16le) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, - 904usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, - 912usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vmprintf) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).overload_function as *const _ as usize - }, - 920usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(overload_function) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, - 928usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize - }, - 936usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).clear_bindings as *const _ as usize - }, - 944usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(clear_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize - }, - 952usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize - }, - 960usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_zeroblob) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, - 968usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_bytes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, - 976usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_close) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, - 984usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, - 992usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_read) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, - 1000usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_write) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation_v2 as *const _ - as usize - }, - 1008usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).file_control as *const _ as usize - }, - 1016usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(file_control) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_highwater as *const _ as usize - }, - 1024usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_highwater) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_used as *const _ as usize - }, - 1032usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_used) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize - }, - 1040usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_alloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_enter as *const _ as usize - }, - 1048usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_enter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, - 1056usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_free) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_leave as *const _ as usize - }, - 1064usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_leave) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, - 1072usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_try) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, - 1080usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).release_memory as *const _ as usize - }, - 1088usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(release_memory) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize - }, - 1096usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_nomem) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_toobig as *const _ - as usize - }, - 1104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_toobig) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, - 1112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sleep) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize - }, - 1120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(soft_heap_limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, - 1128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_find) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_register as *const _ as usize - }, - 1136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_register) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize - }, - 1144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_unregister) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize - }, - 1152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(xthreadsafe) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize - }, - 1160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_zeroblob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_code as *const _ as usize - }, - 1168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_code) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).test_control as *const _ as usize - }, - 1176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(test_control) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, - 1184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(randomness) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).context_db_handle as *const _ as usize - }, - 1192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(context_db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).extended_result_codes as *const _ - as usize - }, - 1200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(extended_result_codes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, - 1208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, - 1216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(next_stmt) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, - 1224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sql) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, - 1232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(status) - ) - ); -} -pub type __builtin_va_list = [__va_list_tag; 1usize]; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct __va_list_tag { - pub gp_offset: ::std::os::raw::c_uint, - pub fp_offset: ::std::os::raw::c_uint, - pub overflow_arg_area: *mut ::std::os::raw::c_void, - pub reg_save_area: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout___va_list_tag() { - assert_eq!( - ::std::mem::size_of::<__va_list_tag>(), - 24usize, - concat!("Size of: ", stringify!(__va_list_tag)) - ); - assert_eq!( - ::std::mem::align_of::<__va_list_tag>(), - 8usize, - concat!("Alignment of ", stringify!(__va_list_tag)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(gp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(fp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(overflow_arg_area) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(reg_save_area) - ) - ); -} - -// bindings were built with loadable_extension_embedded: -// define sqlite3_api as an extern since this code will be embedded -// within a loadable extension that defines and exports this itself -extern "C" { - #[no_mangle] - pub static mut sqlite3_api: *mut sqlite3_api_routines; -} - -// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) - -pub unsafe fn sqlite3_aggregate_context( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_context.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_context", - " function" - )))(arg1, nBytes) -} - -pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_blob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_blob", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_double( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_double", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_null( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_null", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_parameter_index( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_index.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_index", - " function" - )))(arg1, zName) -} - -pub unsafe fn sqlite3_bind_parameter_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_text( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_text16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_bind_value( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_value", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_handler( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_handler", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_timeout( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_timeout.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_timeout", - " function" - )))(arg1, ms) -} - -pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_collation_needed( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_collation_needed16( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_column_blob( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_blob", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_column_database_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_database_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_decltype( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype", - " function" - )))(arg1, i) -} - -pub unsafe fn sqlite3_column_decltype16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_double", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int64( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int64", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_text( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_text16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_type( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_type", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_value( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_value", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_commit_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).commit_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "commit_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete16", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_create_collation( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_collation16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_function( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_function16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function16", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_module( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).data_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "data_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_declare_vtab( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).declare_vtab.expect(stringify!( - "sqlite3_api contains null pointer for ", - "declare_vtab", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).enable_shared_cache.expect(stringify!( - "sqlite3_api contains null pointer for ", - "enable_shared_cache", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errcode", - " function" - )))(db) -} - -pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_exec( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).exec.expect(stringify!( - "sqlite3_api contains null pointer for ", - "exec", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).expired.expect(stringify!( - "sqlite3_api contains null pointer for ", - "expired", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).finalize.expect(stringify!( - "sqlite3_api contains null pointer for ", - "finalize", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free_table", - " function" - )))(result) -} - -pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_autocommit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_autocommit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_get_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_auxdata", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_get_table( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_table", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).global_recover.expect(stringify!( - "sqlite3_api contains null pointer for ", - "global_recover", - " function" - )))() -} - -pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).interruptx.expect(stringify!( - "sqlite3_api contains null pointer for ", - "interruptx", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).last_insert_rowid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "last_insert_rowid", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion", - " function" - )))() -} - -pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion_number.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion_number", - " function" - )))() -} - -pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).malloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "malloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mprintf( - arg1: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mprintf", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_open( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_open16( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_prepare( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_profile( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).profile.expect(stringify!( - "sqlite3_api contains null pointer for ", - "profile", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_progress_handler( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).progress_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "progress_handler", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_realloc( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).realloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "realloc", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).reset.expect(stringify!( - "sqlite3_api contains null pointer for ", - "reset", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_result_blob( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_blob", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_double", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_error16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_null", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_text( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16be( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16be", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16le( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16le", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_value", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_rollback_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).rollback_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "rollback_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_authorizer( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_authorizer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_authorizer", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_auxdata", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_snprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).snprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "snprintf", - " function" - )))(arg1, arg2, arg3, vararg1) -} - -pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).step.expect(stringify!( - "sqlite3_api contains null pointer for ", - "step", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_table_column_metadata( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).table_column_metadata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "table_column_metadata", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) -} - -pub unsafe fn sqlite3_thread_cleanup() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).thread_cleanup.expect(stringify!( - "sqlite3_api contains null pointer for ", - "thread_cleanup", - " function" - )))() -} - -pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).total_changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "total_changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_trace( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).trace.expect(stringify!( - "sqlite3_api contains null pointer for ", - "trace", - " function" - )))(arg1, xTrace, arg2) -} - -pub unsafe fn sqlite3_transfer_bindings( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).transfer_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "transfer_bindings", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_update_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).update_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "update_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).user_data.expect(stringify!( - "sqlite3_api contains null pointer for ", - "user_data", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_blob", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_double", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_numeric_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_numeric_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16be", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16le", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vmprintf( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vmprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vmprintf", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_overload_function( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).overload_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "overload_function", - " function" - )))(arg1, zFuncName, nArg) -} - -pub unsafe fn sqlite3_prepare_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).clear_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "clear_bindings", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_module_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module_v2", - " function" - )))(arg1, arg2, arg3, arg4, xDestroy) -} - -pub unsafe fn sqlite3_bind_zeroblob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_zeroblob", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_open( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_open", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) -} - -pub unsafe fn sqlite3_blob_read( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_read.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_read", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_blob_write( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_write.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_write", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_create_collation_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_file_control( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).file_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "file_control", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_highwater.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_highwater", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_used.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_used", - " function" - )))() -} - -pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_alloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_alloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_enter.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_enter", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_leave.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_leave", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_try.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_try", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_open_v2( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open_v2", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).release_memory.expect(stringify!( - "sqlite3_api contains null pointer for ", - "release_memory", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_nomem.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_nomem", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_toobig.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_toobig", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sleep.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sleep", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).soft_heap_limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "soft_heap_limit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_find.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_find", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_register( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_register.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_register", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_unregister.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_unregister", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).xthreadsafe.expect(stringify!( - "sqlite3_api contains null pointer for ", - "xthreadsafe", - " function" - )))() -} - -pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_zeroblob", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_code.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_code", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_test_control( - arg1: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).test_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "test_control", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).randomness.expect(stringify!( - "sqlite3_api contains null pointer for ", - "randomness", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).context_db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "context_db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_extended_result_codes( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).extended_result_codes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "extended_result_codes", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_limit( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "limit", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).next_stmt.expect(stringify!( - "sqlite3_api contains null pointer for ", - "next_stmt", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sql.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sql", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_status( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "status", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub const SQLITE_DETERMINISTIC: i32 = 2048; diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs index 91f24f7a5..0cbb9e962 100644 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs @@ -4653,11 +4653,9 @@ fn bindgen_test_layout___va_list_tag() { ); } -// bindings were built with (non-embedded) loadable_extension: -// we define our own sqlite_api static variable and export it -// to C -#[no_mangle] -pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_routines; +// sqlite3_api is defined in lib.rs as either a static or an extern when compiled as a loadable_extension +#[cfg(feature = "loadable_extension")] +use crate::sqlite3_api; // sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext-embed.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext-embed.rs deleted file mode 100644 index d589062e5..000000000 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext-embed.rs +++ /dev/null @@ -1,8584 +0,0 @@ -/* automatically generated by rust-bindgen */ - -pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.7.16\0"; -pub const SQLITE_VERSION_NUMBER: i32 = 3007016; -pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = - b"2013-03-18 11:39:23 66d5f2b76750f3520eb7a495f6247206758f5b90\0"; -pub const SQLITE_OK: i32 = 0; -pub const SQLITE_ERROR: i32 = 1; -pub const SQLITE_INTERNAL: i32 = 2; -pub const SQLITE_PERM: i32 = 3; -pub const SQLITE_ABORT: i32 = 4; -pub const SQLITE_BUSY: i32 = 5; -pub const SQLITE_LOCKED: i32 = 6; -pub const SQLITE_NOMEM: i32 = 7; -pub const SQLITE_READONLY: i32 = 8; -pub const SQLITE_INTERRUPT: i32 = 9; -pub const SQLITE_IOERR: i32 = 10; -pub const SQLITE_CORRUPT: i32 = 11; -pub const SQLITE_NOTFOUND: i32 = 12; -pub const SQLITE_FULL: i32 = 13; -pub const SQLITE_CANTOPEN: i32 = 14; -pub const SQLITE_PROTOCOL: i32 = 15; -pub const SQLITE_EMPTY: i32 = 16; -pub const SQLITE_SCHEMA: i32 = 17; -pub const SQLITE_TOOBIG: i32 = 18; -pub const SQLITE_CONSTRAINT: i32 = 19; -pub const SQLITE_MISMATCH: i32 = 20; -pub const SQLITE_MISUSE: i32 = 21; -pub const SQLITE_NOLFS: i32 = 22; -pub const SQLITE_AUTH: i32 = 23; -pub const SQLITE_FORMAT: i32 = 24; -pub const SQLITE_RANGE: i32 = 25; -pub const SQLITE_NOTADB: i32 = 26; -pub const SQLITE_ROW: i32 = 100; -pub const SQLITE_DONE: i32 = 101; -pub const SQLITE_IOERR_READ: i32 = 266; -pub const SQLITE_IOERR_SHORT_READ: i32 = 522; -pub const SQLITE_IOERR_WRITE: i32 = 778; -pub const SQLITE_IOERR_FSYNC: i32 = 1034; -pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; -pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; -pub const SQLITE_IOERR_FSTAT: i32 = 1802; -pub const SQLITE_IOERR_UNLOCK: i32 = 2058; -pub const SQLITE_IOERR_RDLOCK: i32 = 2314; -pub const SQLITE_IOERR_DELETE: i32 = 2570; -pub const SQLITE_IOERR_BLOCKED: i32 = 2826; -pub const SQLITE_IOERR_NOMEM: i32 = 3082; -pub const SQLITE_IOERR_ACCESS: i32 = 3338; -pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; -pub const SQLITE_IOERR_LOCK: i32 = 3850; -pub const SQLITE_IOERR_CLOSE: i32 = 4106; -pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; -pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; -pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; -pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; -pub const SQLITE_IOERR_SHMMAP: i32 = 5386; -pub const SQLITE_IOERR_SEEK: i32 = 5642; -pub const SQLITE_IOERR_DELETE_NOENT: i32 = 5898; -pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; -pub const SQLITE_BUSY_RECOVERY: i32 = 261; -pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; -pub const SQLITE_CANTOPEN_ISDIR: i32 = 526; -pub const SQLITE_CANTOPEN_FULLPATH: i32 = 782; -pub const SQLITE_CORRUPT_VTAB: i32 = 267; -pub const SQLITE_READONLY_RECOVERY: i32 = 264; -pub const SQLITE_READONLY_CANTLOCK: i32 = 520; -pub const SQLITE_READONLY_ROLLBACK: i32 = 776; -pub const SQLITE_ABORT_ROLLBACK: i32 = 516; -pub const SQLITE_CONSTRAINT_CHECK: i32 = 275; -pub const SQLITE_CONSTRAINT_COMMITHOOK: i32 = 531; -pub const SQLITE_CONSTRAINT_FOREIGNKEY: i32 = 787; -pub const SQLITE_CONSTRAINT_FUNCTION: i32 = 1043; -pub const SQLITE_CONSTRAINT_NOTNULL: i32 = 1299; -pub const SQLITE_CONSTRAINT_PRIMARYKEY: i32 = 1555; -pub const SQLITE_CONSTRAINT_TRIGGER: i32 = 1811; -pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067; -pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323; -pub const SQLITE_OPEN_READONLY: i32 = 1; -pub const SQLITE_OPEN_READWRITE: i32 = 2; -pub const SQLITE_OPEN_CREATE: i32 = 4; -pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; -pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; -pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; -pub const SQLITE_OPEN_URI: i32 = 64; -pub const SQLITE_OPEN_MEMORY: i32 = 128; -pub const SQLITE_OPEN_MAIN_DB: i32 = 256; -pub const SQLITE_OPEN_TEMP_DB: i32 = 512; -pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; -pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; -pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; -pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; -pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; -pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; -pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; -pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; -pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; -pub const SQLITE_OPEN_WAL: i32 = 524288; -pub const SQLITE_IOCAP_ATOMIC: i32 = 1; -pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; -pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; -pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; -pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; -pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; -pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; -pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; -pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; -pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; -pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; -pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; -pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE: i32 = 4096; -pub const SQLITE_LOCK_NONE: i32 = 0; -pub const SQLITE_LOCK_SHARED: i32 = 1; -pub const SQLITE_LOCK_RESERVED: i32 = 2; -pub const SQLITE_LOCK_PENDING: i32 = 3; -pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; -pub const SQLITE_SYNC_NORMAL: i32 = 2; -pub const SQLITE_SYNC_FULL: i32 = 3; -pub const SQLITE_SYNC_DATAONLY: i32 = 16; -pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; -pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_LAST_ERRNO: i32 = 4; -pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; -pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; -pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; -pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; -pub const SQLITE_FCNTL_WIN32_AV_RETRY: i32 = 9; -pub const SQLITE_FCNTL_PERSIST_WAL: i32 = 10; -pub const SQLITE_FCNTL_OVERWRITE: i32 = 11; -pub const SQLITE_FCNTL_VFSNAME: i32 = 12; -pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE: i32 = 13; -pub const SQLITE_FCNTL_PRAGMA: i32 = 14; -pub const SQLITE_FCNTL_BUSYHANDLER: i32 = 15; -pub const SQLITE_FCNTL_TEMPFILENAME: i32 = 16; -pub const SQLITE_ACCESS_EXISTS: i32 = 0; -pub const SQLITE_ACCESS_READWRITE: i32 = 1; -pub const SQLITE_ACCESS_READ: i32 = 2; -pub const SQLITE_SHM_UNLOCK: i32 = 1; -pub const SQLITE_SHM_LOCK: i32 = 2; -pub const SQLITE_SHM_SHARED: i32 = 4; -pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; -pub const SQLITE_SHM_NLOCK: i32 = 8; -pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; -pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; -pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; -pub const SQLITE_CONFIG_MALLOC: i32 = 4; -pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; -pub const SQLITE_CONFIG_SCRATCH: i32 = 6; -pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; -pub const SQLITE_CONFIG_HEAP: i32 = 8; -pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; -pub const SQLITE_CONFIG_MUTEX: i32 = 10; -pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; -pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; -pub const SQLITE_CONFIG_PCACHE: i32 = 14; -pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; -pub const SQLITE_CONFIG_LOG: i32 = 16; -pub const SQLITE_CONFIG_URI: i32 = 17; -pub const SQLITE_CONFIG_PCACHE2: i32 = 18; -pub const SQLITE_CONFIG_GETPCACHE2: i32 = 19; -pub const SQLITE_CONFIG_COVERING_INDEX_SCAN: i32 = 20; -pub const SQLITE_CONFIG_SQLLOG: i32 = 21; -pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; -pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; -pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; -pub const SQLITE_DENY: i32 = 1; -pub const SQLITE_IGNORE: i32 = 2; -pub const SQLITE_CREATE_INDEX: i32 = 1; -pub const SQLITE_CREATE_TABLE: i32 = 2; -pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; -pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; -pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; -pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; -pub const SQLITE_CREATE_TRIGGER: i32 = 7; -pub const SQLITE_CREATE_VIEW: i32 = 8; -pub const SQLITE_DELETE: i32 = 9; -pub const SQLITE_DROP_INDEX: i32 = 10; -pub const SQLITE_DROP_TABLE: i32 = 11; -pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; -pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; -pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; -pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; -pub const SQLITE_DROP_TRIGGER: i32 = 16; -pub const SQLITE_DROP_VIEW: i32 = 17; -pub const SQLITE_INSERT: i32 = 18; -pub const SQLITE_PRAGMA: i32 = 19; -pub const SQLITE_READ: i32 = 20; -pub const SQLITE_SELECT: i32 = 21; -pub const SQLITE_TRANSACTION: i32 = 22; -pub const SQLITE_UPDATE: i32 = 23; -pub const SQLITE_ATTACH: i32 = 24; -pub const SQLITE_DETACH: i32 = 25; -pub const SQLITE_ALTER_TABLE: i32 = 26; -pub const SQLITE_REINDEX: i32 = 27; -pub const SQLITE_ANALYZE: i32 = 28; -pub const SQLITE_CREATE_VTABLE: i32 = 29; -pub const SQLITE_DROP_VTABLE: i32 = 30; -pub const SQLITE_FUNCTION: i32 = 31; -pub const SQLITE_SAVEPOINT: i32 = 32; -pub const SQLITE_COPY: i32 = 0; -pub const SQLITE_LIMIT_LENGTH: i32 = 0; -pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; -pub const SQLITE_LIMIT_COLUMN: i32 = 2; -pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; -pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; -pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; -pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; -pub const SQLITE_LIMIT_ATTACHED: i32 = 7; -pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; -pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; -pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; -pub const SQLITE_INTEGER: i32 = 1; -pub const SQLITE_FLOAT: i32 = 2; -pub const SQLITE_BLOB: i32 = 4; -pub const SQLITE_NULL: i32 = 5; -pub const SQLITE_TEXT: i32 = 3; -pub const SQLITE3_TEXT: i32 = 3; -pub const SQLITE_UTF8: i32 = 1; -pub const SQLITE_UTF16LE: i32 = 2; -pub const SQLITE_UTF16BE: i32 = 3; -pub const SQLITE_UTF16: i32 = 4; -pub const SQLITE_ANY: i32 = 5; -pub const SQLITE_UTF16_ALIGNED: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; -pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; -pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; -pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; -pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; -pub const SQLITE_MUTEX_FAST: i32 = 0; -pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; -pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; -pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; -pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; -pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; -pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; -pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; -pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; -pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; -pub const SQLITE_TESTCTRL_FIRST: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; -pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; -pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; -pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; -pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; -pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; -pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; -pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; -pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; -pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; -pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; -pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 17; -pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 18; -pub const SQLITE_TESTCTRL_EXPLAIN_STMT: i32 = 19; -pub const SQLITE_TESTCTRL_LAST: i32 = 19; -pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; -pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; -pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; -pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; -pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; -pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; -pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; -pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; -pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; -pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; -pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; -pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; -pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; -pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; -pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; -pub const SQLITE_DBSTATUS_CACHE_HIT: i32 = 7; -pub const SQLITE_DBSTATUS_CACHE_MISS: i32 = 8; -pub const SQLITE_DBSTATUS_CACHE_WRITE: i32 = 9; -pub const SQLITE_DBSTATUS_MAX: i32 = 9; -pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; -pub const SQLITE_STMTSTATUS_SORT: i32 = 2; -pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; -pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; -pub const SQLITE_CHECKPOINT_FULL: i32 = 1; -pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; -pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; -pub const SQLITE_ROLLBACK: i32 = 1; -pub const SQLITE_FAIL: i32 = 3; -pub const SQLITE_REPLACE: i32 = 5; -pub type va_list = __builtin_va_list; -pub type __gnuc_va_list = __builtin_va_list; -extern "C" { - #[link_name = "\u{1}sqlite3_version"] - pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3 { - _unused: [u8; 0], -} -pub type sqlite_int64 = ::std::os::raw::c_longlong; -pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; -pub type sqlite3_int64 = sqlite_int64; -pub type sqlite3_uint64 = sqlite_uint64; -pub type sqlite3_callback = ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_file { - pub pMethods: *const sqlite3_io_methods, -} -#[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_file)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_file)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_file), - "::", - stringify!(pMethods) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_io_methods { - pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xRead: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *mut ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xWrite: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *const ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pSize: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xUnlock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCheckReservedLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileControl: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - op: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xSectorSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xDeviceCharacteristics: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xShmMap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iPg: ::std::os::raw::c_int, - pgsz: ::std::os::raw::c_int, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xShmLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - offset: ::std::os::raw::c_int, - n: ::std::os::raw::c_int, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xShmBarrier: ::std::option::Option, - pub xShmUnmap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - deleteFlag: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_io_methods() { - assert_eq!( - ::std::mem::size_of::(), - 136usize, - concat!("Size of: ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xRead) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xWrite) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnlock) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xCheckReservedLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileControl) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSectorSize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ - as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xDeviceCharacteristics) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmMap) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmBarrier) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmUnmap) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex { - _unused: [u8; 0], -} -pub type sqlite3_syscall_ptr = ::std::option::Option; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vfs { - pub iVersion: ::std::os::raw::c_int, - pub szOsFile: ::std::os::raw::c_int, - pub mxPathname: ::std::os::raw::c_int, - pub pNext: *mut sqlite3_vfs, - pub zName: *const ::std::os::raw::c_char, - pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - pOutFlags: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - syncDir: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xAccess: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - flags: ::std::os::raw::c_int, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFullPathname: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - nOut: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xDlOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zFilename: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void, - >, - pub xDlError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zErrMsg: *mut ::std::os::raw::c_char, - ), - >, - pub xDlSym: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ) -> ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ), - >, - >, - pub xDlClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), - >, - pub xRandomness: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSleep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - microseconds: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTime: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, - >, - pub xGetLastError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTimeInt64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xSetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: sqlite3_syscall_ptr, - ) -> ::std::os::raw::c_int, - >, - pub xGetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> sqlite3_syscall_ptr, - >, - pub xNextSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!( - ::std::mem::size_of::(), - 168usize, - concat!("Size of: ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(szOsFile) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(mxPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(zName) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pAppData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xAccess) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xFullPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlSym) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xRandomness) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSleep) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTime) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetLastError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTimeInt64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xNextSystemCall) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xRoundup: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub pAppData: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!( - ::std::mem::size_of::(), - 64usize, - concat!("Size of: ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xMalloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xFree) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRealloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRoundup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(pAppData) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Mem { - _unused: [u8; 0], -} -pub type sqlite3_value = Mem; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_context { - _unused: [u8; 0], -} -pub type sqlite3_destructor_type = - ::std::option::Option; -extern "C" { - #[link_name = "\u{1}sqlite3_temp_directory"] - pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; -} -extern "C" { - #[link_name = "\u{1}sqlite3_data_directory"] - pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xConnect: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xBestIndex: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: *mut sqlite3_index_info, - ) -> ::std::os::raw::c_int, - >, - pub xDisconnect: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xDestroy: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - ppCursor: *mut *mut sqlite3_vtab_cursor, - ) -> ::std::os::raw::c_int, - >, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xFilter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - idxNum: ::std::os::raw::c_int, - idxStr: *const ::std::os::raw::c_char, - argc: ::std::os::raw::c_int, - argv: *mut *mut sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub xNext: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xEof: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - arg2: *mut sqlite3_context, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - pRowid: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xUpdate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - arg4: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xBegin: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xCommit: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xRollback: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xFindFunction: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - nArg: ::std::os::raw::c_int, - zName: *const ::std::os::raw::c_char, - pxFunc: *mut ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - ppArg: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xRename: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - zNew: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSavepoint: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRelease: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRollbackTo: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!( - ::std::mem::size_of::(), - 184usize, - concat!("Size of: ", stringify!(sqlite3_module)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_module)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xConnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBestIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDisconnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFilter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xEof) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xColumn) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xUpdate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBegin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCommit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollback) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFindFunction) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRename) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSavepoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRelease) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollbackTo) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info { - pub nConstraint: ::std::os::raw::c_int, - pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, - pub nOrderBy: ::std::os::raw::c_int, - pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, - pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, - pub idxNum: ::std::os::raw::c_int, - pub idxStr: *mut ::std::os::raw::c_char, - pub needToFreeIdxStr: ::std::os::raw::c_int, - pub orderByConsumed: ::std::os::raw::c_int, - pub estimatedCost: f64, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint { - pub iColumn: ::std::os::raw::c_int, - pub op: ::std::os::raw::c_uchar, - pub usable: ::std::os::raw::c_uchar, - pub iTermOffset: ::std::os::raw::c_int, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).op as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(op) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).usable - as *const _ as usize - }, - 5usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(usable) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iTermOffset - as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iTermOffset) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_orderby { - pub iColumn: ::std::os::raw::c_int, - pub desc: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).desc as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(desc) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint_usage { - pub argvIndex: ::std::os::raw::c_int, - pub omit: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).argvIndex - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(argvIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).omit - as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(omit) - ) - ); -} -#[test] -fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nOrderBy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aOrderBy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraintUsage) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxNum) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(needToFreeIdxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(orderByConsumed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedCost as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedCost) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(pModule) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(nRef) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(zErrMsg) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab_cursor { - pub pVtab: *mut sqlite3_vtab, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab_cursor), - "::", - stringify!(pVtab) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexNotheld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexInit as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnd) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexAlloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexFree as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexFree) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexTry) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexLeave) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexHeld) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexNotheld) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_page { - pub pBuf: *mut ::std::os::raw::c_void, - pub pExtra: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_page() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(sqlite3_pcache_page)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_page)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_page), - "::", - stringify!(pBuf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_page), - "::", - stringify!(pExtra) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods2 { - pub iVersion: ::std::os::raw::c_int, - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - szExtra: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache_page, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut sqlite3_pcache_page, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut sqlite3_pcache_page, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, - pub xShrink: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods2() { - assert_eq!( - ::std::mem::size_of::(), - 104usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iVersion as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDestroy as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xShrink) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods { - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!( - ::std::mem::size_of::(), - 88usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xDestroy) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_backup { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_rtree_geometry { - pub pContext: *mut ::std::os::raw::c_void, - pub nParam: ::std::os::raw::c_int, - pub aParam: *mut f64, - pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_rtree_geometry() { - assert_eq!( - ::std::mem::size_of::(), - 40usize, - concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pContext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(nParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(aParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pUser) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(xDelUser) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_api_routines { - pub aggregate_context: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub aggregate_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, - >, - pub bind_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_double: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, - ) -> ::std::os::raw::c_int, - >, - pub bind_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_int64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, - ) -> ::std::os::raw::c_int, - >, - pub bind_null: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub bind_parameter_index: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub bind_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub busy_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub busy_timeout: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub changes: - ::std::option::Option ::std::os::raw::c_int>, - pub close: - ::std::option::Option ::std::os::raw::c_int>, - pub collation_needed: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub collation_needed16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub column_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_bytes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_bytes16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub column_database_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_database_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_decltype: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_decltype16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_double: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, - >, - pub column_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_int64: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, - >, - pub column_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_origin_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_origin_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_table_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_table_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_uchar, - >, - pub column_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_type: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *mut sqlite3_value, - >, - pub commit_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub complete: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, - pub complete16: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub create_collation: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_collation16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_function16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_module: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub data_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub db_handle: - ::std::option::Option *mut sqlite3>, - pub declare_vtab: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub enable_shared_cache: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub errcode: - ::std::option::Option ::std::os::raw::c_int>, - pub errmsg: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, - >, - pub errmsg16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, - >, - pub exec: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub expired: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub finalize: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub free: ::std::option::Option, - pub free_table: - ::std::option::Option, - pub get_autocommit: - ::std::option::Option ::std::os::raw::c_int>, - pub get_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub get_table: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub global_recover: ::std::option::Option ::std::os::raw::c_int>, - pub interruptx: ::std::option::Option, - pub last_insert_rowid: - ::std::option::Option sqlite_int64>, - pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, - pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, - pub malloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub mprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub open16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub prepare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub profile: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub progress_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, - ), - >, - pub realloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub reset: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub result_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_double: - ::std::option::Option, - pub result_error: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_error16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_int64: - ::std::option::Option, - pub result_null: ::std::option::Option, - pub result_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16be: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16le: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_value: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), - >, - pub rollback_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub set_authorizer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub set_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, - ), - >, - pub snprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub step: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub table_column_metadata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub thread_cleanup: ::std::option::Option, - pub total_changes: - ::std::option::Option ::std::os::raw::c_int>, - pub trace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub transfer_bindings: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, - ) -> ::std::os::raw::c_int, - >, - pub update_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub user_data: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, - >, - pub value_blob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_bytes16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_double: ::std::option::Option f64>, - pub value_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_int64: - ::std::option::Option sqlite_int64>, - pub value_numeric_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_text: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, - >, - pub value_text16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16be: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16le: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub vmprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char, - >, - pub overload_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub prepare_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub clear_bindings: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub create_module_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_zeroblob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_close: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, - ) -> ::std::os::raw::c_int, - >, - pub blob_read: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_write: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub create_collation_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub file_control: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub memory_highwater: - ::std::option::Option sqlite3_int64>, - pub memory_used: ::std::option::Option sqlite3_int64>, - pub mutex_alloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub mutex_enter: ::std::option::Option, - pub mutex_free: ::std::option::Option, - pub mutex_leave: ::std::option::Option, - pub mutex_try: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub open_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub release_memory: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub result_error_nomem: ::std::option::Option, - pub result_error_toobig: - ::std::option::Option, - pub sleep: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub soft_heap_limit: ::std::option::Option, - pub vfs_find: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, - >, - pub vfs_register: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub vfs_unregister: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, - >, - pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, - pub result_zeroblob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_error_code: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub test_control: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, - >, - pub randomness: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), - >, - pub context_db_handle: - ::std::option::Option *mut sqlite3>, - pub extended_result_codes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub limit: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub next_stmt: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, - >, - pub sql: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, - >, - pub status: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub backup_finish: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_init: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut sqlite3, - arg4: *const ::std::os::raw::c_char, - ) -> *mut sqlite3_backup, - >, - pub backup_pagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_remaining: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_step: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_backup, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub compileoption_get: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, - >, - pub compileoption_used: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, - pub create_function_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub db_config: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int, - >, - pub db_mutex: - ::std::option::Option *mut sqlite3_mutex>, - pub db_status: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub extended_errcode: - ::std::option::Option ::std::os::raw::c_int>, - pub log: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char, ...), - >, - pub soft_heap_limit64: - ::std::option::Option sqlite3_int64>, - pub sourceid: ::std::option::Option *const ::std::os::raw::c_char>, - pub stmt_status: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub strnicmp: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub unlock_notify: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub wal_autocheckpoint: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub wal_checkpoint: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub wal_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub blob_reopen: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob, arg2: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub vtab_config: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int, - >, - pub vtab_on_conflict: - ::std::option::Option ::std::os::raw::c_int>, - pub close_v2: - ::std::option::Option ::std::os::raw::c_int>, - pub db_filename: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, - pub db_readonly: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub db_release_memory: - ::std::option::Option ::std::os::raw::c_int>, - pub errstr: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, - >, - pub stmt_busy: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub stmt_readonly: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub stricmp: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub uri_boolean: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub uri_int64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_int64, - ) -> sqlite3_int64, - >, - pub uri_parameter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, - pub vsnprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char, - >, - pub wal_checkpoint_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_api_routines() { - assert_eq!( - ::std::mem::size_of::(), - 1536usize, - concat!("Size of: ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_context as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_context) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_count as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_double as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_count as *const _ - as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_index as *const _ - as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_index) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_name as *const _ - as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_text16 as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_handler as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_handler) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_timeout as *const _ as usize - }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_timeout) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(close) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed as *const _ as usize - }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_blob as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes as *const _ as usize - }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize - }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_count as *const _ as usize - }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name as *const _ - as usize - }, - 184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name16 as *const _ - as usize - }, - 192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype as *const _ as usize - }, - 200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize - }, - 208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_double as *const _ as usize - }, - 216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, - 224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_int64 as *const _ as usize - }, - 232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name as *const _ as usize - }, - 240usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name16 as *const _ as usize - }, - 248usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name as *const _ as usize - }, - 256usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name16 as *const _ - as usize - }, - 264usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name as *const _ as usize - }, - 272usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name16 as *const _ - as usize - }, - 280usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text as *const _ as usize - }, - 288usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text16 as *const _ as usize - }, - 296usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_type as *const _ as usize - }, - 304usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_type) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_value as *const _ as usize - }, - 312usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).commit_hook as *const _ as usize - }, - 320usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(commit_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, - 328usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, - 336usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation as *const _ as usize - }, - 344usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation16 as *const _ as usize - }, - 352usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function as *const _ as usize - }, - 360usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function16 as *const _ as usize - }, - 368usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module as *const _ as usize - }, - 376usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, - 384usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(data_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, - 392usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).declare_vtab as *const _ as usize - }, - 400usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(declare_vtab) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).enable_shared_cache as *const _ - as usize - }, - 408usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(enable_shared_cache) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, - 416usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, - 424usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, - 432usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, - 440usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(exec) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, - 448usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(expired) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, - 456usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(finalize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, - 464usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, - 472usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_autocommit as *const _ as usize - }, - 480usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_autocommit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_auxdata as *const _ as usize - }, - 488usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, - 496usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).global_recover as *const _ as usize - }, - 504usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(global_recover) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, - 512usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(interruptx) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize - }, - 520usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(last_insert_rowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, - 528usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).libversion_number as *const _ as usize - }, - 536usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion_number) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, - 544usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(malloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, - 552usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, - 560usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, - 568usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, - 576usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, - 584usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, - 592usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(profile) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).progress_handler as *const _ as usize - }, - 600usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(progress_handler) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, - 608usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(realloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, - 616usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(reset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_blob as *const _ as usize - }, - 624usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_double as *const _ as usize - }, - 632usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_double) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error as *const _ as usize - }, - 640usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error16 as *const _ as usize - }, - 648usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, - 656usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_int64 as *const _ as usize - }, - 664usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_null as *const _ as usize - }, - 672usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text as *const _ as usize - }, - 680usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16 as *const _ as usize - }, - 688usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16be as *const _ as usize - }, - 696usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16le as *const _ as usize - }, - 704usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16le) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_value as *const _ as usize - }, - 712usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rollback_hook as *const _ as usize - }, - 720usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(rollback_hook) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_authorizer as *const _ as usize - }, - 728usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_authorizer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_auxdata as *const _ as usize - }, - 736usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).snprintf as *const _ as usize }, - 744usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(snprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, - 752usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(step) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).table_column_metadata as *const _ - as usize - }, - 760usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(table_column_metadata) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize - }, - 768usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(thread_cleanup) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).total_changes as *const _ as usize - }, - 776usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(total_changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, - 784usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(trace) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize - }, - 792usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(transfer_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).update_hook as *const _ as usize - }, - 800usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(update_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, - 808usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(user_data) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, - 816usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes as *const _ as usize - }, - 824usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize - }, - 832usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_double as *const _ as usize - }, - 840usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, - 848usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_int64 as *const _ as usize - }, - 856usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize - }, - 864usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_numeric_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, - 872usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16 as *const _ as usize - }, - 880usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16be as *const _ as usize - }, - 888usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16le as *const _ as usize - }, - 896usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16le) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, - 904usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, - 912usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vmprintf) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).overload_function as *const _ as usize - }, - 920usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(overload_function) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, - 928usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize - }, - 936usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).clear_bindings as *const _ as usize - }, - 944usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(clear_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize - }, - 952usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize - }, - 960usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_zeroblob) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, - 968usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_bytes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, - 976usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_close) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, - 984usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, - 992usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_read) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, - 1000usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_write) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation_v2 as *const _ - as usize - }, - 1008usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).file_control as *const _ as usize - }, - 1016usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(file_control) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_highwater as *const _ as usize - }, - 1024usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_highwater) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_used as *const _ as usize - }, - 1032usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_used) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize - }, - 1040usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_alloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_enter as *const _ as usize - }, - 1048usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_enter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, - 1056usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_free) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_leave as *const _ as usize - }, - 1064usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_leave) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, - 1072usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_try) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, - 1080usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).release_memory as *const _ as usize - }, - 1088usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(release_memory) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize - }, - 1096usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_nomem) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_toobig as *const _ - as usize - }, - 1104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_toobig) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, - 1112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sleep) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize - }, - 1120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(soft_heap_limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, - 1128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_find) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_register as *const _ as usize - }, - 1136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_register) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize - }, - 1144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_unregister) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize - }, - 1152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(xthreadsafe) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize - }, - 1160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_zeroblob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_code as *const _ as usize - }, - 1168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_code) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).test_control as *const _ as usize - }, - 1176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(test_control) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, - 1184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(randomness) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).context_db_handle as *const _ as usize - }, - 1192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(context_db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).extended_result_codes as *const _ - as usize - }, - 1200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(extended_result_codes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, - 1208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, - 1216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(next_stmt) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, - 1224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sql) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, - 1232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(status) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_finish as *const _ as usize - }, - 1240usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_finish) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_init as *const _ as usize - }, - 1248usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_init) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_pagecount as *const _ as usize - }, - 1256usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_pagecount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_remaining as *const _ as usize - }, - 1264usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_remaining) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_step as *const _ as usize - }, - 1272usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_step) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).compileoption_get as *const _ as usize - }, - 1280usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(compileoption_get) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).compileoption_used as *const _ as usize - }, - 1288usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(compileoption_used) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function_v2 as *const _ as usize - }, - 1296usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function_v2) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_config as *const _ as usize }, - 1304usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_config) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_mutex as *const _ as usize }, - 1312usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_mutex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_status as *const _ as usize }, - 1320usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_status) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).extended_errcode as *const _ as usize - }, - 1328usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(extended_errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).log as *const _ as usize }, - 1336usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(log) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).soft_heap_limit64 as *const _ as usize - }, - 1344usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(soft_heap_limit64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sourceid as *const _ as usize }, - 1352usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sourceid) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stmt_status as *const _ as usize - }, - 1360usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_status) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).strnicmp as *const _ as usize }, - 1368usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(strnicmp) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).unlock_notify as *const _ as usize - }, - 1376usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(unlock_notify) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_autocheckpoint as *const _ as usize - }, - 1384usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_autocheckpoint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_checkpoint as *const _ as usize - }, - 1392usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_checkpoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).wal_hook as *const _ as usize }, - 1400usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_hook) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).blob_reopen as *const _ as usize - }, - 1408usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_reopen) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtab_config as *const _ as usize - }, - 1416usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vtab_config) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtab_on_conflict as *const _ as usize - }, - 1424usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vtab_on_conflict) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).close_v2 as *const _ as usize }, - 1432usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(close_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_filename as *const _ as usize - }, - 1440usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_filename) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_readonly as *const _ as usize - }, - 1448usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_readonly) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_release_memory as *const _ as usize - }, - 1456usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_release_memory) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errstr as *const _ as usize }, - 1464usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errstr) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).stmt_busy as *const _ as usize }, - 1472usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_busy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stmt_readonly as *const _ as usize - }, - 1480usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_readonly) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).stricmp as *const _ as usize }, - 1488usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stricmp) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).uri_boolean as *const _ as usize - }, - 1496usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(uri_boolean) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).uri_int64 as *const _ as usize }, - 1504usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(uri_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).uri_parameter as *const _ as usize - }, - 1512usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(uri_parameter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vsnprintf as *const _ as usize }, - 1520usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vsnprintf) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_checkpoint_v2 as *const _ as usize - }, - 1528usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_checkpoint_v2) - ) - ); -} -pub type __builtin_va_list = [__va_list_tag; 1usize]; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct __va_list_tag { - pub gp_offset: ::std::os::raw::c_uint, - pub fp_offset: ::std::os::raw::c_uint, - pub overflow_arg_area: *mut ::std::os::raw::c_void, - pub reg_save_area: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout___va_list_tag() { - assert_eq!( - ::std::mem::size_of::<__va_list_tag>(), - 24usize, - concat!("Size of: ", stringify!(__va_list_tag)) - ); - assert_eq!( - ::std::mem::align_of::<__va_list_tag>(), - 8usize, - concat!("Alignment of ", stringify!(__va_list_tag)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(gp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(fp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(overflow_arg_area) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(reg_save_area) - ) - ); -} - -// bindings were built with loadable_extension_embedded: -// define sqlite3_api as an extern since this code will be embedded -// within a loadable extension that defines and exports this itself -extern "C" { - #[no_mangle] - pub static mut sqlite3_api: *mut sqlite3_api_routines; -} - -// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) - -pub unsafe fn sqlite3_aggregate_context( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_context.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_context", - " function" - )))(arg1, nBytes) -} - -pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_blob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_blob", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_double( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_double", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_null( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_null", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_parameter_index( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_index.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_index", - " function" - )))(arg1, zName) -} - -pub unsafe fn sqlite3_bind_parameter_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_text( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_text16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_bind_value( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_value", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_handler( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_handler", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_timeout( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_timeout.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_timeout", - " function" - )))(arg1, ms) -} - -pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_collation_needed( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_collation_needed16( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_column_blob( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_blob", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_column_database_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_database_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_decltype( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype", - " function" - )))(arg1, i) -} - -pub unsafe fn sqlite3_column_decltype16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_double", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int64( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int64", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_text( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_text16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_type( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_type", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_value( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_value", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_commit_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).commit_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "commit_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete16", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_create_collation( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_collation16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_function( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_function16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function16", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_module( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).data_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "data_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_declare_vtab( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).declare_vtab.expect(stringify!( - "sqlite3_api contains null pointer for ", - "declare_vtab", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).enable_shared_cache.expect(stringify!( - "sqlite3_api contains null pointer for ", - "enable_shared_cache", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errcode", - " function" - )))(db) -} - -pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_exec( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).exec.expect(stringify!( - "sqlite3_api contains null pointer for ", - "exec", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).expired.expect(stringify!( - "sqlite3_api contains null pointer for ", - "expired", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).finalize.expect(stringify!( - "sqlite3_api contains null pointer for ", - "finalize", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free_table", - " function" - )))(result) -} - -pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_autocommit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_autocommit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_get_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_auxdata", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_get_table( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_table", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).global_recover.expect(stringify!( - "sqlite3_api contains null pointer for ", - "global_recover", - " function" - )))() -} - -pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).interruptx.expect(stringify!( - "sqlite3_api contains null pointer for ", - "interruptx", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).last_insert_rowid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "last_insert_rowid", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion", - " function" - )))() -} - -pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion_number.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion_number", - " function" - )))() -} - -pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).malloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "malloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mprintf( - arg1: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mprintf", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_open( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_open16( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_prepare( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_profile( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).profile.expect(stringify!( - "sqlite3_api contains null pointer for ", - "profile", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_progress_handler( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).progress_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "progress_handler", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_realloc( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).realloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "realloc", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).reset.expect(stringify!( - "sqlite3_api contains null pointer for ", - "reset", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_result_blob( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_blob", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_double", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_error16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_null", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_text( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16be( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16be", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16le( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16le", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_value", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_rollback_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).rollback_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "rollback_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_authorizer( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_authorizer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_authorizer", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_auxdata", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_snprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).snprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "snprintf", - " function" - )))(arg1, arg2, arg3, vararg1) -} - -pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).step.expect(stringify!( - "sqlite3_api contains null pointer for ", - "step", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_table_column_metadata( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).table_column_metadata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "table_column_metadata", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) -} - -pub unsafe fn sqlite3_thread_cleanup() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).thread_cleanup.expect(stringify!( - "sqlite3_api contains null pointer for ", - "thread_cleanup", - " function" - )))() -} - -pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).total_changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "total_changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_trace( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).trace.expect(stringify!( - "sqlite3_api contains null pointer for ", - "trace", - " function" - )))(arg1, xTrace, arg2) -} - -pub unsafe fn sqlite3_transfer_bindings( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).transfer_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "transfer_bindings", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_update_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).update_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "update_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).user_data.expect(stringify!( - "sqlite3_api contains null pointer for ", - "user_data", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_blob", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_double", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_numeric_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_numeric_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16be", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16le", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vmprintf( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vmprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vmprintf", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_overload_function( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).overload_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "overload_function", - " function" - )))(arg1, zFuncName, nArg) -} - -pub unsafe fn sqlite3_prepare_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).clear_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "clear_bindings", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_module_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module_v2", - " function" - )))(arg1, arg2, arg3, arg4, xDestroy) -} - -pub unsafe fn sqlite3_bind_zeroblob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_zeroblob", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_open( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_open", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) -} - -pub unsafe fn sqlite3_blob_read( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_read.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_read", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_blob_write( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_write.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_write", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_create_collation_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_file_control( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).file_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "file_control", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_highwater.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_highwater", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_used.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_used", - " function" - )))() -} - -pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_alloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_alloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_enter.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_enter", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_leave.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_leave", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_try.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_try", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_open_v2( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open_v2", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).release_memory.expect(stringify!( - "sqlite3_api contains null pointer for ", - "release_memory", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_nomem.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_nomem", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_toobig.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_toobig", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sleep.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sleep", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).soft_heap_limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "soft_heap_limit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_find.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_find", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_register( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_register.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_register", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_unregister.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_unregister", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).xthreadsafe.expect(stringify!( - "sqlite3_api contains null pointer for ", - "xthreadsafe", - " function" - )))() -} - -pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_zeroblob", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_code.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_code", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_test_control( - arg1: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).test_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "test_control", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).randomness.expect(stringify!( - "sqlite3_api contains null pointer for ", - "randomness", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).context_db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "context_db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_extended_result_codes( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).extended_result_codes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "extended_result_codes", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_limit( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "limit", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).next_stmt.expect(stringify!( - "sqlite3_api contains null pointer for ", - "next_stmt", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sql.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sql", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_status( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "status", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_finish.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_finish", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_init( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut sqlite3, - arg4: *const ::std::os::raw::c_char, -) -> *mut sqlite3_backup { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_init.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_init", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_pagecount.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_pagecount", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_remaining.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_remaining", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_step( - arg1: *mut sqlite3_backup, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_step.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_step", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_compileoption_get( - arg1: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).compileoption_get.expect(stringify!( - "sqlite3_api contains null pointer for ", - "compileoption_get", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_compileoption_used( - arg1: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).compileoption_used.expect(stringify!( - "sqlite3_api contains null pointer for ", - "compileoption_used", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_function_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal, xDestroy) -} - -pub unsafe fn sqlite3_db_config( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, - vararg2: &mut i32, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_config.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_config", - " function" - )))(arg1, arg2, vararg1, vararg2) -} - -pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_mutex.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_mutex", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_db_status( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_status", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).extended_errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "extended_errcode", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_log( - arg1: ::std::os::raw::c_int, - arg2: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).log.expect(stringify!( - "sqlite3_api contains null pointer for ", - "log", - " function" - )))(arg1, arg2, vararg1) -} - -pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).soft_heap_limit64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "soft_heap_limit64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sourceid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sourceid", - " function" - )))() -} - -pub unsafe fn sqlite3_stmt_status( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_status", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_strnicmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).strnicmp.expect(stringify!( - "sqlite3_api contains null pointer for ", - "strnicmp", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_unlock_notify( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int), - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).unlock_notify.expect(stringify!( - "sqlite3_api contains null pointer for ", - "unlock_notify", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_wal_autocheckpoint( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_autocheckpoint", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_wal_checkpoint( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_checkpoint.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_checkpoint", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_wal_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_blob_reopen( - arg1: *mut sqlite3_blob, - arg2: sqlite3_int64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_reopen.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_reopen", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vtab_config( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vtab_config.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vtab_config", - " function" - )))(arg1, op, vararg1) -} - -pub unsafe fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vtab_on_conflict.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vtab_on_conflict", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "close_v2", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_db_filename( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_filename.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_filename", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_db_readonly( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_readonly.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_readonly", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_release_memory.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_release_memory", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errstr.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errstr", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_busy.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_busy", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_stmt_readonly(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_readonly.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_readonly", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_stricmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stricmp.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stricmp", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_uri_boolean( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).uri_boolean.expect(stringify!( - "sqlite3_api contains null pointer for ", - "uri_boolean", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_uri_int64( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_int64, -) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).uri_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "uri_int64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_uri_parameter( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).uri_parameter.expect(stringify!( - "sqlite3_api contains null pointer for ", - "uri_parameter", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vsnprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut __va_list_tag, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vsnprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vsnprintf", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_wal_checkpoint_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_checkpoint_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_checkpoint_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub const SQLITE_DETERMINISTIC: i32 = 2048; diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs index 51fa550df..a5b13632b 100644 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs @@ -5879,11 +5879,9 @@ fn bindgen_test_layout___va_list_tag() { ); } -// bindings were built with (non-embedded) loadable_extension: -// we define our own sqlite_api static variable and export it -// to C -#[no_mangle] -pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_routines; +// sqlite3_api is defined in lib.rs as either a static or an extern when compiled as a loadable_extension +#[cfg(feature = "loadable_extension")] +use crate::sqlite3_api; // sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index 1bf740ab9..50c9137a8 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -365,9 +365,7 @@ mod bindings { } fn prebuilt_bindgen_ext() -> &'static str { - if cfg!(feature = "loadable_extension_embedded") { - "-ext-embed" - } else if cfg!(feature = "loadable_extension") { + if cfg!(feature = "loadable_extension") { "-ext" } else { "" @@ -446,11 +444,11 @@ mod bindings { // Get the list of API functions supported by sqlite3_api_routines, // set the corresponding sqlite3 api routine to be blacklisted in the // final bindgen run, and add wrappers for each of the API functions to - // dispatch the API call through a sqlite3_api global, which is also - // declared in the bindings (either as a built-in or an extern symbol - // in the case of loadable_extension_embedded (i.e. when the rust code - // will be a part of an extension but not implement the extension - // entrypoint itself). + // dispatch the API call through a sqlite3_api global, which is defined + // outside the generated bindings in lib.rs, either as a built-in static + // or an extern symbol in the case of loadable_extension_embedded (i.e. + // when the rust code will be a part of an extension but not implement + // the extension entrypoint itself). #[cfg(feature = "loadable_extension")] { let api_routines_struct_name = "sqlite3_api_routines".to_owned(); @@ -464,46 +462,22 @@ mod bindings { ); } }; - - #[cfg(feature = "loadable_extension_embedded")] - { - // an embedded loadable extension is one in which the rust code will be linked - // in to external code that implements the loadable extension - // and exports the sqlite3_api interface as a symbol - output.push_str( - r#" - -// bindings were built with loadable_extension_embedded: -// define sqlite3_api as an extern since this code will be embedded -// within a loadable extension that defines and exports this itself -extern { - #[no_mangle] - pub static mut sqlite3_api: *mut sqlite3_api_routines; -} - -"#, - ); - } - - #[cfg(not(feature = "loadable_extension_embedded"))] + + #[cfg(feature = "loadable_extension")] { - // a non-embedded loadable extension is a standalone rust loadable extension, - // so we need our own sqlite3_api global output.push_str( r#" -// bindings were built with (non-embedded) loadable_extension: -// we define our own sqlite_api static variable and export it -// to C -#[no_mangle] -pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_routines; +// sqlite3_api is defined in lib.rs as either a static or an extern when compiled as a loadable_extension +#[cfg(feature = "loadable_extension")] +use crate::sqlite3_api; "#, ); } - + output.push_str( - r" + r" // sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) "); diff --git a/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext-embed.rs b/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext-embed.rs deleted file mode 100644 index fa164e120..000000000 --- a/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext-embed.rs +++ /dev/null @@ -1,11383 +0,0 @@ -/* automatically generated by rust-bindgen */ - -pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.31.0\0"; -pub const SQLITE_VERSION_NUMBER: i32 = 3031000; -pub const SQLITE_SOURCE_ID: &'static [u8; 85usize] = - b"2020-01-22 18:38:59 f6affdd41608946fcfcea914ece149038a8b25a62bbe719ed2561c649b86d824\0"; -pub const SQLITE_OK: i32 = 0; -pub const SQLITE_ERROR: i32 = 1; -pub const SQLITE_INTERNAL: i32 = 2; -pub const SQLITE_PERM: i32 = 3; -pub const SQLITE_ABORT: i32 = 4; -pub const SQLITE_BUSY: i32 = 5; -pub const SQLITE_LOCKED: i32 = 6; -pub const SQLITE_NOMEM: i32 = 7; -pub const SQLITE_READONLY: i32 = 8; -pub const SQLITE_INTERRUPT: i32 = 9; -pub const SQLITE_IOERR: i32 = 10; -pub const SQLITE_CORRUPT: i32 = 11; -pub const SQLITE_NOTFOUND: i32 = 12; -pub const SQLITE_FULL: i32 = 13; -pub const SQLITE_CANTOPEN: i32 = 14; -pub const SQLITE_PROTOCOL: i32 = 15; -pub const SQLITE_EMPTY: i32 = 16; -pub const SQLITE_SCHEMA: i32 = 17; -pub const SQLITE_TOOBIG: i32 = 18; -pub const SQLITE_CONSTRAINT: i32 = 19; -pub const SQLITE_MISMATCH: i32 = 20; -pub const SQLITE_MISUSE: i32 = 21; -pub const SQLITE_NOLFS: i32 = 22; -pub const SQLITE_AUTH: i32 = 23; -pub const SQLITE_FORMAT: i32 = 24; -pub const SQLITE_RANGE: i32 = 25; -pub const SQLITE_NOTADB: i32 = 26; -pub const SQLITE_NOTICE: i32 = 27; -pub const SQLITE_WARNING: i32 = 28; -pub const SQLITE_ROW: i32 = 100; -pub const SQLITE_DONE: i32 = 101; -pub const SQLITE_ERROR_MISSING_COLLSEQ: i32 = 257; -pub const SQLITE_ERROR_RETRY: i32 = 513; -pub const SQLITE_ERROR_SNAPSHOT: i32 = 769; -pub const SQLITE_IOERR_READ: i32 = 266; -pub const SQLITE_IOERR_SHORT_READ: i32 = 522; -pub const SQLITE_IOERR_WRITE: i32 = 778; -pub const SQLITE_IOERR_FSYNC: i32 = 1034; -pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; -pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; -pub const SQLITE_IOERR_FSTAT: i32 = 1802; -pub const SQLITE_IOERR_UNLOCK: i32 = 2058; -pub const SQLITE_IOERR_RDLOCK: i32 = 2314; -pub const SQLITE_IOERR_DELETE: i32 = 2570; -pub const SQLITE_IOERR_BLOCKED: i32 = 2826; -pub const SQLITE_IOERR_NOMEM: i32 = 3082; -pub const SQLITE_IOERR_ACCESS: i32 = 3338; -pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; -pub const SQLITE_IOERR_LOCK: i32 = 3850; -pub const SQLITE_IOERR_CLOSE: i32 = 4106; -pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; -pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; -pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; -pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; -pub const SQLITE_IOERR_SHMMAP: i32 = 5386; -pub const SQLITE_IOERR_SEEK: i32 = 5642; -pub const SQLITE_IOERR_DELETE_NOENT: i32 = 5898; -pub const SQLITE_IOERR_MMAP: i32 = 6154; -pub const SQLITE_IOERR_GETTEMPPATH: i32 = 6410; -pub const SQLITE_IOERR_CONVPATH: i32 = 6666; -pub const SQLITE_IOERR_VNODE: i32 = 6922; -pub const SQLITE_IOERR_AUTH: i32 = 7178; -pub const SQLITE_IOERR_BEGIN_ATOMIC: i32 = 7434; -pub const SQLITE_IOERR_COMMIT_ATOMIC: i32 = 7690; -pub const SQLITE_IOERR_ROLLBACK_ATOMIC: i32 = 7946; -pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; -pub const SQLITE_LOCKED_VTAB: i32 = 518; -pub const SQLITE_BUSY_RECOVERY: i32 = 261; -pub const SQLITE_BUSY_SNAPSHOT: i32 = 517; -pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; -pub const SQLITE_CANTOPEN_ISDIR: i32 = 526; -pub const SQLITE_CANTOPEN_FULLPATH: i32 = 782; -pub const SQLITE_CANTOPEN_CONVPATH: i32 = 1038; -pub const SQLITE_CANTOPEN_DIRTYWAL: i32 = 1294; -pub const SQLITE_CANTOPEN_SYMLINK: i32 = 1550; -pub const SQLITE_CORRUPT_VTAB: i32 = 267; -pub const SQLITE_CORRUPT_SEQUENCE: i32 = 523; -pub const SQLITE_READONLY_RECOVERY: i32 = 264; -pub const SQLITE_READONLY_CANTLOCK: i32 = 520; -pub const SQLITE_READONLY_ROLLBACK: i32 = 776; -pub const SQLITE_READONLY_DBMOVED: i32 = 1032; -pub const SQLITE_READONLY_CANTINIT: i32 = 1288; -pub const SQLITE_READONLY_DIRECTORY: i32 = 1544; -pub const SQLITE_ABORT_ROLLBACK: i32 = 516; -pub const SQLITE_CONSTRAINT_CHECK: i32 = 275; -pub const SQLITE_CONSTRAINT_COMMITHOOK: i32 = 531; -pub const SQLITE_CONSTRAINT_FOREIGNKEY: i32 = 787; -pub const SQLITE_CONSTRAINT_FUNCTION: i32 = 1043; -pub const SQLITE_CONSTRAINT_NOTNULL: i32 = 1299; -pub const SQLITE_CONSTRAINT_PRIMARYKEY: i32 = 1555; -pub const SQLITE_CONSTRAINT_TRIGGER: i32 = 1811; -pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067; -pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323; -pub const SQLITE_CONSTRAINT_ROWID: i32 = 2579; -pub const SQLITE_CONSTRAINT_PINNED: i32 = 2835; -pub const SQLITE_NOTICE_RECOVER_WAL: i32 = 283; -pub const SQLITE_NOTICE_RECOVER_ROLLBACK: i32 = 539; -pub const SQLITE_WARNING_AUTOINDEX: i32 = 284; -pub const SQLITE_AUTH_USER: i32 = 279; -pub const SQLITE_OK_LOAD_PERMANENTLY: i32 = 256; -pub const SQLITE_OK_SYMLINK: i32 = 512; -pub const SQLITE_OPEN_READONLY: i32 = 1; -pub const SQLITE_OPEN_READWRITE: i32 = 2; -pub const SQLITE_OPEN_CREATE: i32 = 4; -pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; -pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; -pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; -pub const SQLITE_OPEN_URI: i32 = 64; -pub const SQLITE_OPEN_MEMORY: i32 = 128; -pub const SQLITE_OPEN_MAIN_DB: i32 = 256; -pub const SQLITE_OPEN_TEMP_DB: i32 = 512; -pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; -pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; -pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; -pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; -pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; -pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; -pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; -pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; -pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; -pub const SQLITE_OPEN_WAL: i32 = 524288; -pub const SQLITE_OPEN_NOFOLLOW: i32 = 16777216; -pub const SQLITE_IOCAP_ATOMIC: i32 = 1; -pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; -pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; -pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; -pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; -pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; -pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; -pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; -pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; -pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; -pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; -pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; -pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE: i32 = 4096; -pub const SQLITE_IOCAP_IMMUTABLE: i32 = 8192; -pub const SQLITE_IOCAP_BATCH_ATOMIC: i32 = 16384; -pub const SQLITE_LOCK_NONE: i32 = 0; -pub const SQLITE_LOCK_SHARED: i32 = 1; -pub const SQLITE_LOCK_RESERVED: i32 = 2; -pub const SQLITE_LOCK_PENDING: i32 = 3; -pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; -pub const SQLITE_SYNC_NORMAL: i32 = 2; -pub const SQLITE_SYNC_FULL: i32 = 3; -pub const SQLITE_SYNC_DATAONLY: i32 = 16; -pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; -pub const SQLITE_FCNTL_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_FCNTL_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_FCNTL_LAST_ERRNO: i32 = 4; -pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; -pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; -pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; -pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; -pub const SQLITE_FCNTL_WIN32_AV_RETRY: i32 = 9; -pub const SQLITE_FCNTL_PERSIST_WAL: i32 = 10; -pub const SQLITE_FCNTL_OVERWRITE: i32 = 11; -pub const SQLITE_FCNTL_VFSNAME: i32 = 12; -pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE: i32 = 13; -pub const SQLITE_FCNTL_PRAGMA: i32 = 14; -pub const SQLITE_FCNTL_BUSYHANDLER: i32 = 15; -pub const SQLITE_FCNTL_TEMPFILENAME: i32 = 16; -pub const SQLITE_FCNTL_MMAP_SIZE: i32 = 18; -pub const SQLITE_FCNTL_TRACE: i32 = 19; -pub const SQLITE_FCNTL_HAS_MOVED: i32 = 20; -pub const SQLITE_FCNTL_SYNC: i32 = 21; -pub const SQLITE_FCNTL_COMMIT_PHASETWO: i32 = 22; -pub const SQLITE_FCNTL_WIN32_SET_HANDLE: i32 = 23; -pub const SQLITE_FCNTL_WAL_BLOCK: i32 = 24; -pub const SQLITE_FCNTL_ZIPVFS: i32 = 25; -pub const SQLITE_FCNTL_RBU: i32 = 26; -pub const SQLITE_FCNTL_VFS_POINTER: i32 = 27; -pub const SQLITE_FCNTL_JOURNAL_POINTER: i32 = 28; -pub const SQLITE_FCNTL_WIN32_GET_HANDLE: i32 = 29; -pub const SQLITE_FCNTL_PDB: i32 = 30; -pub const SQLITE_FCNTL_BEGIN_ATOMIC_WRITE: i32 = 31; -pub const SQLITE_FCNTL_COMMIT_ATOMIC_WRITE: i32 = 32; -pub const SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE: i32 = 33; -pub const SQLITE_FCNTL_LOCK_TIMEOUT: i32 = 34; -pub const SQLITE_FCNTL_DATA_VERSION: i32 = 35; -pub const SQLITE_FCNTL_SIZE_LIMIT: i32 = 36; -pub const SQLITE_FCNTL_CKPT_DONE: i32 = 37; -pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; -pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; -pub const SQLITE_LAST_ERRNO: i32 = 4; -pub const SQLITE_ACCESS_EXISTS: i32 = 0; -pub const SQLITE_ACCESS_READWRITE: i32 = 1; -pub const SQLITE_ACCESS_READ: i32 = 2; -pub const SQLITE_SHM_UNLOCK: i32 = 1; -pub const SQLITE_SHM_LOCK: i32 = 2; -pub const SQLITE_SHM_SHARED: i32 = 4; -pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; -pub const SQLITE_SHM_NLOCK: i32 = 8; -pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; -pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; -pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; -pub const SQLITE_CONFIG_MALLOC: i32 = 4; -pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; -pub const SQLITE_CONFIG_SCRATCH: i32 = 6; -pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; -pub const SQLITE_CONFIG_HEAP: i32 = 8; -pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; -pub const SQLITE_CONFIG_MUTEX: i32 = 10; -pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; -pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; -pub const SQLITE_CONFIG_PCACHE: i32 = 14; -pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; -pub const SQLITE_CONFIG_LOG: i32 = 16; -pub const SQLITE_CONFIG_URI: i32 = 17; -pub const SQLITE_CONFIG_PCACHE2: i32 = 18; -pub const SQLITE_CONFIG_GETPCACHE2: i32 = 19; -pub const SQLITE_CONFIG_COVERING_INDEX_SCAN: i32 = 20; -pub const SQLITE_CONFIG_SQLLOG: i32 = 21; -pub const SQLITE_CONFIG_MMAP_SIZE: i32 = 22; -pub const SQLITE_CONFIG_WIN32_HEAPSIZE: i32 = 23; -pub const SQLITE_CONFIG_PCACHE_HDRSZ: i32 = 24; -pub const SQLITE_CONFIG_PMASZ: i32 = 25; -pub const SQLITE_CONFIG_STMTJRNL_SPILL: i32 = 26; -pub const SQLITE_CONFIG_SMALL_MALLOC: i32 = 27; -pub const SQLITE_CONFIG_SORTERREF_SIZE: i32 = 28; -pub const SQLITE_CONFIG_MEMDB_MAXSIZE: i32 = 29; -pub const SQLITE_DBCONFIG_MAINDBNAME: i32 = 1000; -pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; -pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; -pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; -pub const SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: i32 = 1004; -pub const SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: i32 = 1005; -pub const SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE: i32 = 1006; -pub const SQLITE_DBCONFIG_ENABLE_QPSG: i32 = 1007; -pub const SQLITE_DBCONFIG_TRIGGER_EQP: i32 = 1008; -pub const SQLITE_DBCONFIG_RESET_DATABASE: i32 = 1009; -pub const SQLITE_DBCONFIG_DEFENSIVE: i32 = 1010; -pub const SQLITE_DBCONFIG_WRITABLE_SCHEMA: i32 = 1011; -pub const SQLITE_DBCONFIG_LEGACY_ALTER_TABLE: i32 = 1012; -pub const SQLITE_DBCONFIG_DQS_DML: i32 = 1013; -pub const SQLITE_DBCONFIG_DQS_DDL: i32 = 1014; -pub const SQLITE_DBCONFIG_ENABLE_VIEW: i32 = 1015; -pub const SQLITE_DBCONFIG_LEGACY_FILE_FORMAT: i32 = 1016; -pub const SQLITE_DBCONFIG_TRUSTED_SCHEMA: i32 = 1017; -pub const SQLITE_DBCONFIG_MAX: i32 = 1017; -pub const SQLITE_DENY: i32 = 1; -pub const SQLITE_IGNORE: i32 = 2; -pub const SQLITE_CREATE_INDEX: i32 = 1; -pub const SQLITE_CREATE_TABLE: i32 = 2; -pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; -pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; -pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; -pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; -pub const SQLITE_CREATE_TRIGGER: i32 = 7; -pub const SQLITE_CREATE_VIEW: i32 = 8; -pub const SQLITE_DELETE: i32 = 9; -pub const SQLITE_DROP_INDEX: i32 = 10; -pub const SQLITE_DROP_TABLE: i32 = 11; -pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; -pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; -pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; -pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; -pub const SQLITE_DROP_TRIGGER: i32 = 16; -pub const SQLITE_DROP_VIEW: i32 = 17; -pub const SQLITE_INSERT: i32 = 18; -pub const SQLITE_PRAGMA: i32 = 19; -pub const SQLITE_READ: i32 = 20; -pub const SQLITE_SELECT: i32 = 21; -pub const SQLITE_TRANSACTION: i32 = 22; -pub const SQLITE_UPDATE: i32 = 23; -pub const SQLITE_ATTACH: i32 = 24; -pub const SQLITE_DETACH: i32 = 25; -pub const SQLITE_ALTER_TABLE: i32 = 26; -pub const SQLITE_REINDEX: i32 = 27; -pub const SQLITE_ANALYZE: i32 = 28; -pub const SQLITE_CREATE_VTABLE: i32 = 29; -pub const SQLITE_DROP_VTABLE: i32 = 30; -pub const SQLITE_FUNCTION: i32 = 31; -pub const SQLITE_SAVEPOINT: i32 = 32; -pub const SQLITE_COPY: i32 = 0; -pub const SQLITE_RECURSIVE: i32 = 33; -pub const SQLITE_TRACE_STMT: i32 = 1; -pub const SQLITE_TRACE_PROFILE: i32 = 2; -pub const SQLITE_TRACE_ROW: i32 = 4; -pub const SQLITE_TRACE_CLOSE: i32 = 8; -pub const SQLITE_LIMIT_LENGTH: i32 = 0; -pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; -pub const SQLITE_LIMIT_COLUMN: i32 = 2; -pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; -pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; -pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; -pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; -pub const SQLITE_LIMIT_ATTACHED: i32 = 7; -pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; -pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; -pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; -pub const SQLITE_LIMIT_WORKER_THREADS: i32 = 11; -pub const SQLITE_PREPARE_PERSISTENT: i32 = 1; -pub const SQLITE_PREPARE_NORMALIZE: i32 = 2; -pub const SQLITE_PREPARE_NO_VTAB: i32 = 4; -pub const SQLITE_INTEGER: i32 = 1; -pub const SQLITE_FLOAT: i32 = 2; -pub const SQLITE_BLOB: i32 = 4; -pub const SQLITE_NULL: i32 = 5; -pub const SQLITE_TEXT: i32 = 3; -pub const SQLITE3_TEXT: i32 = 3; -pub const SQLITE_UTF8: i32 = 1; -pub const SQLITE_UTF16LE: i32 = 2; -pub const SQLITE_UTF16BE: i32 = 3; -pub const SQLITE_UTF16: i32 = 4; -pub const SQLITE_ANY: i32 = 5; -pub const SQLITE_UTF16_ALIGNED: i32 = 8; -pub const SQLITE_DETERMINISTIC: i32 = 2048; -pub const SQLITE_DIRECTONLY: i32 = 524288; -pub const SQLITE_SUBTYPE: i32 = 1048576; -pub const SQLITE_INNOCUOUS: i32 = 2097152; -pub const SQLITE_WIN32_DATA_DIRECTORY_TYPE: i32 = 1; -pub const SQLITE_WIN32_TEMP_DIRECTORY_TYPE: i32 = 2; -pub const SQLITE_INDEX_SCAN_UNIQUE: i32 = 1; -pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; -pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; -pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; -pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; -pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; -pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; -pub const SQLITE_INDEX_CONSTRAINT_LIKE: i32 = 65; -pub const SQLITE_INDEX_CONSTRAINT_GLOB: i32 = 66; -pub const SQLITE_INDEX_CONSTRAINT_REGEXP: i32 = 67; -pub const SQLITE_INDEX_CONSTRAINT_NE: i32 = 68; -pub const SQLITE_INDEX_CONSTRAINT_ISNOT: i32 = 69; -pub const SQLITE_INDEX_CONSTRAINT_ISNOTNULL: i32 = 70; -pub const SQLITE_INDEX_CONSTRAINT_ISNULL: i32 = 71; -pub const SQLITE_INDEX_CONSTRAINT_IS: i32 = 72; -pub const SQLITE_INDEX_CONSTRAINT_FUNCTION: i32 = 150; -pub const SQLITE_MUTEX_FAST: i32 = 0; -pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; -pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; -pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; -pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; -pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; -pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; -pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; -pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; -pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; -pub const SQLITE_MUTEX_STATIC_APP1: i32 = 8; -pub const SQLITE_MUTEX_STATIC_APP2: i32 = 9; -pub const SQLITE_MUTEX_STATIC_APP3: i32 = 10; -pub const SQLITE_MUTEX_STATIC_VFS1: i32 = 11; -pub const SQLITE_MUTEX_STATIC_VFS2: i32 = 12; -pub const SQLITE_MUTEX_STATIC_VFS3: i32 = 13; -pub const SQLITE_TESTCTRL_FIRST: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; -pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; -pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; -pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; -pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; -pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; -pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; -pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; -pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; -pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; -pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; -pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; -pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 17; -pub const SQLITE_TESTCTRL_INTERNAL_FUNCTIONS: i32 = 17; -pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 18; -pub const SQLITE_TESTCTRL_EXPLAIN_STMT: i32 = 19; -pub const SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD: i32 = 19; -pub const SQLITE_TESTCTRL_NEVER_CORRUPT: i32 = 20; -pub const SQLITE_TESTCTRL_VDBE_COVERAGE: i32 = 21; -pub const SQLITE_TESTCTRL_BYTEORDER: i32 = 22; -pub const SQLITE_TESTCTRL_ISINIT: i32 = 23; -pub const SQLITE_TESTCTRL_SORTER_MMAP: i32 = 24; -pub const SQLITE_TESTCTRL_IMPOSTER: i32 = 25; -pub const SQLITE_TESTCTRL_PARSER_COVERAGE: i32 = 26; -pub const SQLITE_TESTCTRL_RESULT_INTREAL: i32 = 27; -pub const SQLITE_TESTCTRL_PRNG_SEED: i32 = 28; -pub const SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS: i32 = 29; -pub const SQLITE_TESTCTRL_LAST: i32 = 29; -pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; -pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; -pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; -pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; -pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; -pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; -pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; -pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; -pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; -pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; -pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; -pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; -pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; -pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; -pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; -pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; -pub const SQLITE_DBSTATUS_CACHE_HIT: i32 = 7; -pub const SQLITE_DBSTATUS_CACHE_MISS: i32 = 8; -pub const SQLITE_DBSTATUS_CACHE_WRITE: i32 = 9; -pub const SQLITE_DBSTATUS_DEFERRED_FKS: i32 = 10; -pub const SQLITE_DBSTATUS_CACHE_USED_SHARED: i32 = 11; -pub const SQLITE_DBSTATUS_CACHE_SPILL: i32 = 12; -pub const SQLITE_DBSTATUS_MAX: i32 = 12; -pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; -pub const SQLITE_STMTSTATUS_SORT: i32 = 2; -pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; -pub const SQLITE_STMTSTATUS_VM_STEP: i32 = 4; -pub const SQLITE_STMTSTATUS_REPREPARE: i32 = 5; -pub const SQLITE_STMTSTATUS_RUN: i32 = 6; -pub const SQLITE_STMTSTATUS_MEMUSED: i32 = 99; -pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; -pub const SQLITE_CHECKPOINT_FULL: i32 = 1; -pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; -pub const SQLITE_CHECKPOINT_TRUNCATE: i32 = 3; -pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; -pub const SQLITE_VTAB_INNOCUOUS: i32 = 2; -pub const SQLITE_VTAB_DIRECTONLY: i32 = 3; -pub const SQLITE_ROLLBACK: i32 = 1; -pub const SQLITE_FAIL: i32 = 3; -pub const SQLITE_REPLACE: i32 = 5; -pub const SQLITE_SCANSTAT_NLOOP: i32 = 0; -pub const SQLITE_SCANSTAT_NVISIT: i32 = 1; -pub const SQLITE_SCANSTAT_EST: i32 = 2; -pub const SQLITE_SCANSTAT_NAME: i32 = 3; -pub const SQLITE_SCANSTAT_EXPLAIN: i32 = 4; -pub const SQLITE_SCANSTAT_SELECTID: i32 = 5; -pub const SQLITE_SERIALIZE_NOCOPY: i32 = 1; -pub const SQLITE_DESERIALIZE_FREEONCLOSE: i32 = 1; -pub const SQLITE_DESERIALIZE_RESIZEABLE: i32 = 2; -pub const SQLITE_DESERIALIZE_READONLY: i32 = 4; -pub const NOT_WITHIN: i32 = 0; -pub const PARTLY_WITHIN: i32 = 1; -pub const FULLY_WITHIN: i32 = 2; -pub const FTS5_TOKENIZE_QUERY: i32 = 1; -pub const FTS5_TOKENIZE_PREFIX: i32 = 2; -pub const FTS5_TOKENIZE_DOCUMENT: i32 = 4; -pub const FTS5_TOKENIZE_AUX: i32 = 8; -pub const FTS5_TOKEN_COLOCATED: i32 = 1; -pub type va_list = __builtin_va_list; -pub type __gnuc_va_list = __builtin_va_list; -extern "C" { - pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3 { - _unused: [u8; 0], -} -pub type sqlite_int64 = ::std::os::raw::c_longlong; -pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; -pub type sqlite3_int64 = sqlite_int64; -pub type sqlite3_uint64 = sqlite_uint64; -pub type sqlite3_callback = ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_file { - pub pMethods: *const sqlite3_io_methods, -} -#[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_file)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_file)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_file), - "::", - stringify!(pMethods) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_io_methods { - pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xRead: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *mut ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xWrite: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: *const ::std::os::raw::c_void, - iAmt: ::std::os::raw::c_int, - iOfst: sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pSize: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xUnlock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCheckReservedLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFileControl: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - op: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xSectorSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xDeviceCharacteristics: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, - >, - pub xShmMap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iPg: ::std::os::raw::c_int, - pgsz: ::std::os::raw::c_int, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xShmLock: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - offset: ::std::os::raw::c_int, - n: ::std::os::raw::c_int, - flags: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xShmBarrier: ::std::option::Option, - pub xShmUnmap: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - deleteFlag: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iOfst: sqlite3_int64, - iAmt: ::std::os::raw::c_int, - pp: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xUnfetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_file, - iOfst: sqlite3_int64, - p: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_io_methods() { - assert_eq!( - ::std::mem::size_of::(), - 152usize, - concat!("Size of: ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_io_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xRead) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xWrite) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnlock) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xCheckReservedLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFileControl) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xSectorSize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ - as usize - }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xDeviceCharacteristics) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmMap) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmLock) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmBarrier) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xShmUnmap) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnfetch as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_io_methods), - "::", - stringify!(xUnfetch) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex { - _unused: [u8; 0], -} -pub type sqlite3_syscall_ptr = ::std::option::Option; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vfs { - pub iVersion: ::std::os::raw::c_int, - pub szOsFile: ::std::os::raw::c_int, - pub mxPathname: ::std::os::raw::c_int, - pub pNext: *mut sqlite3_vfs, - pub zName: *const ::std::os::raw::c_char, - pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: *mut sqlite3_file, - flags: ::std::os::raw::c_int, - pOutFlags: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - syncDir: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xAccess: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - flags: ::std::os::raw::c_int, - pResOut: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xFullPathname: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - nOut: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xDlOpen: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zFilename: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void, - >, - pub xDlError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zErrMsg: *mut ::std::os::raw::c_char, - ), - >, - pub xDlSym: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ) -> ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut ::std::os::raw::c_void, - zSymbol: *const ::std::os::raw::c_char, - ), - >, - >, - pub xDlClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), - >, - pub xRandomness: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - nByte: ::std::os::raw::c_int, - zOut: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSleep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - microseconds: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTime: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, - >, - pub xGetLastError: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xCurrentTimeInt64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xSetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - arg2: sqlite3_syscall_ptr, - ) -> ::std::os::raw::c_int, - >, - pub xGetSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> sqlite3_syscall_ptr, - >, - pub xNextSystemCall: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - zName: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!( - ::std::mem::size_of::(), - 168usize, - concat!("Size of: ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vfs)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(szOsFile) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(mxPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(zName) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(pAppData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xAccess) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xFullPathname) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlSym) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xDlClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xRandomness) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSleep) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTime) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetLastError) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xCurrentTimeInt64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xSetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xGetSystemCall) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vfs), - "::", - stringify!(xNextSystemCall) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xSize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xRoundup: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub pAppData: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!( - ::std::mem::size_of::(), - 64usize, - concat!("Size of: ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mem_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xMalloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xFree) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRealloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xRoundup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mem_methods), - "::", - stringify!(pAppData) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_value { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_context { - _unused: [u8; 0], -} -pub type sqlite3_destructor_type = - ::std::option::Option; -extern "C" { - pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; -} -extern "C" { - pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xConnect: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - pAux: *mut ::std::os::raw::c_void, - argc: ::std::os::raw::c_int, - argv: *const *const ::std::os::raw::c_char, - ppVTab: *mut *mut sqlite3_vtab, - arg2: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xBestIndex: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: *mut sqlite3_index_info, - ) -> ::std::os::raw::c_int, - >, - pub xDisconnect: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xDestroy: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xOpen: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - ppCursor: *mut *mut sqlite3_vtab_cursor, - ) -> ::std::os::raw::c_int, - >, - pub xClose: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xFilter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - idxNum: ::std::os::raw::c_int, - idxStr: *const ::std::os::raw::c_char, - argc: ::std::os::raw::c_int, - argv: *mut *mut sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub xNext: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xEof: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, - >, - pub xColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - arg2: *mut sqlite3_context, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab_cursor, - pRowid: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xUpdate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vtab, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - arg4: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xBegin: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xSync: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xCommit: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xRollback: ::std::option::Option< - unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, - >, - pub xFindFunction: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - nArg: ::std::os::raw::c_int, - zName: *const ::std::os::raw::c_char, - pxFunc: *mut ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - ppArg: *mut *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub xRename: ::std::option::Option< - unsafe extern "C" fn( - pVtab: *mut sqlite3_vtab, - zNew: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub xSavepoint: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRelease: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRollbackTo: ::std::option::Option< - unsafe extern "C" fn( - pVTab: *mut sqlite3_vtab, - arg1: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xShadowName: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!( - ::std::mem::size_of::(), - 192usize, - concat!("Size of: ", stringify!(sqlite3_module)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_module)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xConnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBestIndex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDisconnect) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xOpen) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xClose) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFilter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xNext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xEof) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xColumn) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xUpdate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xBegin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSync) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xCommit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollback) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xFindFunction) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRename) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xSavepoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRelease) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xRollbackTo) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShadowName as *const _ as usize }, - 184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_module), - "::", - stringify!(xShadowName) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info { - pub nConstraint: ::std::os::raw::c_int, - pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, - pub nOrderBy: ::std::os::raw::c_int, - pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, - pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, - pub idxNum: ::std::os::raw::c_int, - pub idxStr: *mut ::std::os::raw::c_char, - pub needToFreeIdxStr: ::std::os::raw::c_int, - pub orderByConsumed: ::std::os::raw::c_int, - pub estimatedCost: f64, - pub estimatedRows: sqlite3_int64, - pub idxFlags: ::std::os::raw::c_int, - pub colUsed: sqlite3_uint64, -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint { - pub iColumn: ::std::os::raw::c_int, - pub op: ::std::os::raw::c_uchar, - pub usable: ::std::os::raw::c_uchar, - pub iTermOffset: ::std::os::raw::c_int, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!( - ::std::mem::size_of::(), - 12usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).op as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(op) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).usable - as *const _ as usize - }, - 5usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(usable) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iTermOffset - as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint), - "::", - stringify!(iTermOffset) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_orderby { - pub iColumn: ::std::os::raw::c_int, - pub desc: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_orderby) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iColumn as *const _ - as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(iColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).desc as *const _ - as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_orderby), - "::", - stringify!(desc) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_index_info_sqlite3_index_constraint_usage { - pub argvIndex: ::std::os::raw::c_int, - pub omit: ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!( - "Size of: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).argvIndex - as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(argvIndex) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).omit - as *const _ as usize - }, - 4usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), - "::", - stringify!(omit) - ) - ); -} -#[test] -fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!( - ::std::mem::size_of::(), - 96usize, - concat!("Size of: ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_index_info)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(nOrderBy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aOrderBy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(aConstraintUsage) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxNum) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(needToFreeIdxStr) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize - }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(orderByConsumed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedCost as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedCost) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).estimatedRows as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(estimatedRows) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).idxFlags as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(idxFlags) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).colUsed as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_index_info), - "::", - stringify!(colUsed) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(pModule) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(nRef) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab), - "::", - stringify!(zErrMsg) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_vtab_cursor { - pub pVtab: *mut sqlite3_vtab, -} -#[test] -fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!( - ::std::mem::size_of::(), - 8usize, - concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_vtab_cursor), - "::", - stringify!(pVtab) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub xMutexNotheld: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!( - ::std::mem::size_of::(), - 72usize, - concat!("Size of: ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexInit as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexInit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnd) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexAlloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexFree as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexFree) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexEnter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexTry) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexLeave) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexHeld) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_mutex_methods), - "::", - stringify!(xMutexNotheld) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_str { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_page { - pub pBuf: *mut ::std::os::raw::c_void, - pub pExtra: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_page() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(sqlite3_pcache_page)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_page)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_page), - "::", - stringify!(pBuf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_page), - "::", - stringify!(pExtra) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods2 { - pub iVersion: ::std::os::raw::c_int, - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - szExtra: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache_page, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut sqlite3_pcache_page, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut sqlite3_pcache_page, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, - pub xShrink: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods2() { - assert_eq!( - ::std::mem::size_of::(), - 104usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).iVersion as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDestroy as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xDestroy) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods2), - "::", - stringify!(xShrink) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache_methods { - pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - szPage: ::std::os::raw::c_int, - bPurgeable: ::std::os::raw::c_int, - ) -> *mut sqlite3_pcache, - >, - pub xCachesize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), - >, - pub xPagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, - >, - pub xFetch: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - key: ::std::os::raw::c_uint, - createFlag: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xUnpin: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - discard: ::std::os::raw::c_int, - ), - >, - pub xRekey: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_pcache, - arg2: *mut ::std::os::raw::c_void, - oldKey: ::std::os::raw::c_uint, - newKey: ::std::os::raw::c_uint, - ), - >, - pub xTruncate: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), - >, - pub xDestroy: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!( - ::std::mem::size_of::(), - 88usize, - concat!("Size of: ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(pArg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xInit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xShutdown as *const _ as usize - }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xShutdown) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xCachesize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xCachesize) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPagecount as *const _ as usize - }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xPagecount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xFetch) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xUnpin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xRekey) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xTruncate as *const _ as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xTruncate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_pcache_methods), - "::", - stringify!(xDestroy) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_backup { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct sqlite3_snapshot { - pub hidden: [::std::os::raw::c_uchar; 48usize], -} -#[test] -fn bindgen_test_layout_sqlite3_snapshot() { - assert_eq!( - ::std::mem::size_of::(), - 48usize, - concat!("Size of: ", stringify!(sqlite3_snapshot)) - ); - assert_eq!( - ::std::mem::align_of::(), - 1usize, - concat!("Alignment of ", stringify!(sqlite3_snapshot)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).hidden as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_snapshot), - "::", - stringify!(hidden) - ) - ); -} -pub type sqlite3_rtree_dbl = f64; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_rtree_geometry { - pub pContext: *mut ::std::os::raw::c_void, - pub nParam: ::std::os::raw::c_int, - pub aParam: *mut sqlite3_rtree_dbl, - pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, -} -#[test] -fn bindgen_test_layout_sqlite3_rtree_geometry() { - assert_eq!( - ::std::mem::size_of::(), - 40usize, - concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pContext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(nParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(aParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(pUser) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_geometry), - "::", - stringify!(xDelUser) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_rtree_query_info { - pub pContext: *mut ::std::os::raw::c_void, - pub nParam: ::std::os::raw::c_int, - pub aParam: *mut sqlite3_rtree_dbl, - pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, - pub aCoord: *mut sqlite3_rtree_dbl, - pub anQueue: *mut ::std::os::raw::c_uint, - pub nCoord: ::std::os::raw::c_int, - pub iLevel: ::std::os::raw::c_int, - pub mxLevel: ::std::os::raw::c_int, - pub iRowid: sqlite3_int64, - pub rParentScore: sqlite3_rtree_dbl, - pub eParentWithin: ::std::os::raw::c_int, - pub eWithin: ::std::os::raw::c_int, - pub rScore: sqlite3_rtree_dbl, - pub apSqlParam: *mut *mut sqlite3_value, -} -#[test] -fn bindgen_test_layout_sqlite3_rtree_query_info() { - assert_eq!( - ::std::mem::size_of::(), - 112usize, - concat!("Size of: ", stringify!(sqlite3_rtree_query_info)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_rtree_query_info)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).pContext as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(pContext) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(nParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(aParam) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(pUser) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xDelUser as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(xDelUser) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).aCoord as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(aCoord) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).anQueue as *const _ as usize - }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(anQueue) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).nCoord as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(nCoord) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iLevel as *const _ as usize }, - 60usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(iLevel) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mxLevel as *const _ as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(mxLevel) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iRowid as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(iRowid) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rParentScore as *const _ as usize - }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(rParentScore) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).eParentWithin as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(eParentWithin) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).eWithin as *const _ as usize - }, - 92usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(eWithin) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).rScore as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(rScore) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).apSqlParam as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_rtree_query_info), - "::", - stringify!(apSqlParam) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5Context { - _unused: [u8; 0], -} -pub type fts5_extension_function = ::std::option::Option< - unsafe extern "C" fn( - pApi: *const Fts5ExtensionApi, - pFts: *mut Fts5Context, - pCtx: *mut sqlite3_context, - nVal: ::std::os::raw::c_int, - apVal: *mut *mut sqlite3_value, - ), ->; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5PhraseIter { - pub a: *const ::std::os::raw::c_uchar, - pub b: *const ::std::os::raw::c_uchar, -} -#[test] -fn bindgen_test_layout_Fts5PhraseIter() { - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(Fts5PhraseIter)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Fts5PhraseIter)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).a as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Fts5PhraseIter), - "::", - stringify!(a) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).b as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Fts5PhraseIter), - "::", - stringify!(b) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5ExtensionApi { - pub iVersion: ::std::os::raw::c_int, - pub xUserData: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> *mut ::std::os::raw::c_void, - >, - pub xColumnCount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, - >, - pub xRowCount: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pnRow: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xColumnTotalSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pnToken: *mut sqlite3_int64, - ) -> ::std::os::raw::c_int, - >, - pub xTokenize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pText: *const ::std::os::raw::c_char, - nText: ::std::os::raw::c_int, - pCtx: *mut ::std::os::raw::c_void, - xToken: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, - arg6: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseCount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int, - >, - pub xPhraseSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xInstCount: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pnInst: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xInst: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iIdx: ::std::os::raw::c_int, - piPhrase: *mut ::std::os::raw::c_int, - piCol: *mut ::std::os::raw::c_int, - piOff: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xRowid: - ::std::option::Option sqlite3_int64>, - pub xColumnText: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pz: *mut *const ::std::os::raw::c_char, - pn: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xColumnSize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iCol: ::std::os::raw::c_int, - pnToken: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xQueryPhrase: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - pUserData: *mut ::std::os::raw::c_void, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const Fts5ExtensionApi, - arg2: *mut Fts5Context, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub xSetAuxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - pAux: *mut ::std::os::raw::c_void, - xDelete: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub xGetAuxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - bClear: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub xPhraseFirst: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - arg2: *mut Fts5PhraseIter, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseNext: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - arg2: *mut Fts5PhraseIter, - piCol: *mut ::std::os::raw::c_int, - piOff: *mut ::std::os::raw::c_int, - ), - >, - pub xPhraseFirstColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - iPhrase: ::std::os::raw::c_int, - arg2: *mut Fts5PhraseIter, - arg3: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub xPhraseNextColumn: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Context, - arg2: *mut Fts5PhraseIter, - piCol: *mut ::std::os::raw::c_int, - ), - >, -} -#[test] -fn bindgen_test_layout_Fts5ExtensionApi() { - assert_eq!( - ::std::mem::size_of::(), - 160usize, - concat!("Size of: ", stringify!(Fts5ExtensionApi)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(Fts5ExtensionApi)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xUserData as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xUserData) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnCount as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowCount as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xRowCount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xColumnTotalSize as *const _ as usize - }, - 32usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnTotalSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xTokenize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseCount as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseSize as *const _ as usize }, - 56usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInstCount as *const _ as usize }, - 64usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xInstCount) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xInst as *const _ as usize }, - 72usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xInst) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xRowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnText as *const _ as usize }, - 88usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnText) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xColumnSize as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xColumnSize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xQueryPhrase as *const _ as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xQueryPhrase) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xSetAuxdata as *const _ as usize }, - 112usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xSetAuxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xGetAuxdata as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xGetAuxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseFirst as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseFirst) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xPhraseNext as *const _ as usize }, - 136usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseNext) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPhraseFirstColumn as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseFirstColumn) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xPhraseNextColumn as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(Fts5ExtensionApi), - "::", - stringify!(xPhraseNextColumn) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct Fts5Tokenizer { - _unused: [u8; 0], -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct fts5_tokenizer { - pub xCreate: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - azArg: *mut *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ppOut: *mut *mut Fts5Tokenizer, - ) -> ::std::os::raw::c_int, - >, - pub xDelete: ::std::option::Option, - pub xTokenize: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut Fts5Tokenizer, - pCtx: *mut ::std::os::raw::c_void, - flags: ::std::os::raw::c_int, - pText: *const ::std::os::raw::c_char, - nText: ::std::os::raw::c_int, - xToken: ::std::option::Option< - unsafe extern "C" fn( - pCtx: *mut ::std::os::raw::c_void, - tflags: ::std::os::raw::c_int, - pToken: *const ::std::os::raw::c_char, - nToken: ::std::os::raw::c_int, - iStart: ::std::os::raw::c_int, - iEnd: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_fts5_tokenizer() { - assert_eq!( - ::std::mem::size_of::(), - 24usize, - concat!("Size of: ", stringify!(fts5_tokenizer)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(fts5_tokenizer)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xCreate) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xDelete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xTokenize as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(fts5_tokenizer), - "::", - stringify!(xTokenize) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct fts5_api { - pub iVersion: ::std::os::raw::c_int, - pub xCreateTokenizer: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - pContext: *mut ::std::os::raw::c_void, - pTokenizer: *mut fts5_tokenizer, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub xFindTokenizer: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - ppContext: *mut *mut ::std::os::raw::c_void, - pTokenizer: *mut fts5_tokenizer, - ) -> ::std::os::raw::c_int, - >, - pub xCreateFunction: ::std::option::Option< - unsafe extern "C" fn( - pApi: *mut fts5_api, - zName: *const ::std::os::raw::c_char, - pContext: *mut ::std::os::raw::c_void, - xFunction: fts5_extension_function, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, -} -#[test] -fn bindgen_test_layout_fts5_api() { - assert_eq!( - ::std::mem::size_of::(), - 32usize, - concat!("Size of: ", stringify!(fts5_api)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(fts5_api)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(iVersion) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreateTokenizer as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xCreateTokenizer) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xFindTokenizer as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xFindTokenizer) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xCreateFunction as *const _ as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(fts5_api), - "::", - stringify!(xCreateFunction) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct sqlite3_api_routines { - pub aggregate_context: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub aggregate_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, - >, - pub bind_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_double: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, - ) -> ::std::os::raw::c_int, - >, - pub bind_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_int64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, - ) -> ::std::os::raw::c_int, - >, - pub bind_null: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_count: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub bind_parameter_index: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub bind_parameter_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub bind_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, - ) -> ::std::os::raw::c_int, - >, - pub busy_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub busy_timeout: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub changes: - ::std::option::Option ::std::os::raw::c_int>, - pub close: - ::std::option::Option ::std::os::raw::c_int>, - pub collation_needed: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub collation_needed16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, - ) -> ::std::os::raw::c_int, - >, - pub column_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_bytes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_bytes16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub column_database_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_database_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_decltype: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_decltype16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_double: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, - >, - pub column_int: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_int64: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, - >, - pub column_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_origin_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_origin_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_table_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub column_table_name16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_uchar, - >, - pub column_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_void, - >, - pub column_type: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub column_value: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, - ) -> *mut sqlite3_value, - >, - pub commit_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub complete: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, - pub complete16: ::std::option::Option< - unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - pub create_collation: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_collation16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - ) -> ::std::os::raw::c_int, - >, - pub create_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_function16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub create_module: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub data_count: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub db_handle: - ::std::option::Option *mut sqlite3>, - pub declare_vtab: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub enable_shared_cache: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub errcode: - ::std::option::Option ::std::os::raw::c_int>, - pub errmsg: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, - >, - pub errmsg16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, - >, - pub exec: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub expired: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub finalize: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub free: ::std::option::Option, - pub free_table: - ::std::option::Option, - pub get_autocommit: - ::std::option::Option ::std::os::raw::c_int>, - pub get_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub get_table: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub global_recover: ::std::option::Option ::std::os::raw::c_int>, - pub interruptx: ::std::option::Option, - pub last_insert_rowid: - ::std::option::Option sqlite_int64>, - pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, - pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, - pub malloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, - >, - pub mprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub open16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, - ) -> ::std::os::raw::c_int, - >, - pub prepare: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub profile: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub progress_handler: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, - ), - >, - pub realloc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> *mut ::std::os::raw::c_void, - >, - pub reset: ::std::option::Option< - unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub result_blob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_double: - ::std::option::Option, - pub result_error: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_error16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - ), - >, - pub result_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_int64: - ::std::option::Option, - pub result_null: ::std::option::Option, - pub result_text: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16be: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_text16le: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, - ), - >, - pub result_value: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), - >, - pub rollback_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub set_authorizer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub set_auxdata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, - ), - >, - pub xsnprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - ... - ) -> *mut ::std::os::raw::c_char, - >, - pub step: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub table_column_metadata: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub thread_cleanup: ::std::option::Option, - pub total_changes: - ::std::option::Option ::std::os::raw::c_int>, - pub trace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub transfer_bindings: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, - ) -> ::std::os::raw::c_int, - >, - pub update_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub user_data: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, - >, - pub value_blob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_bytes16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_double: ::std::option::Option f64>, - pub value_int: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_int64: - ::std::option::Option sqlite_int64>, - pub value_numeric_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub value_text: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, - >, - pub value_text16: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16be: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_text16le: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, - >, - pub value_type: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub vmprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char, - >, - pub overload_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub prepare_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub clear_bindings: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub create_module_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_zeroblob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_bytes: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_close: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, - >, - pub blob_open: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, - ) -> ::std::os::raw::c_int, - >, - pub blob_read: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub blob_write: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub create_collation_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub file_control: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub memory_highwater: - ::std::option::Option sqlite3_int64>, - pub memory_used: ::std::option::Option sqlite3_int64>, - pub mutex_alloc: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, - >, - pub mutex_enter: ::std::option::Option, - pub mutex_free: ::std::option::Option, - pub mutex_leave: ::std::option::Option, - pub mutex_try: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, - >, - pub open_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub release_memory: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub result_error_nomem: ::std::option::Option, - pub result_error_toobig: - ::std::option::Option, - pub sleep: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, - >, - pub soft_heap_limit: ::std::option::Option, - pub vfs_find: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, - >, - pub vfs_register: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub vfs_unregister: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, - >, - pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, - pub result_zeroblob: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub result_error_code: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), - >, - pub test_control: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, - >, - pub randomness: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), - >, - pub context_db_handle: - ::std::option::Option *mut sqlite3>, - pub extended_result_codes: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub limit: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub next_stmt: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, - >, - pub sql: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, - >, - pub status: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub backup_finish: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_init: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut sqlite3, - arg4: *const ::std::os::raw::c_char, - ) -> *mut sqlite3_backup, - >, - pub backup_pagecount: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_remaining: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, - >, - pub backup_step: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_backup, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub compileoption_get: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, - >, - pub compileoption_used: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, - >, - pub create_function_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub db_config: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int, - >, - pub db_mutex: - ::std::option::Option *mut sqlite3_mutex>, - pub db_status: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub extended_errcode: - ::std::option::Option ::std::os::raw::c_int>, - pub log: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char, ...), - >, - pub soft_heap_limit64: - ::std::option::Option sqlite3_int64>, - pub sourceid: ::std::option::Option *const ::std::os::raw::c_char>, - pub stmt_status: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub strnicmp: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub unlock_notify: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ), - >, - arg3: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub wal_autocheckpoint: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub wal_checkpoint: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub wal_hook: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, - ) -> *mut ::std::os::raw::c_void, - >, - pub blob_reopen: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_blob, arg2: sqlite3_int64) -> ::std::os::raw::c_int, - >, - pub vtab_config: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - ... - ) -> ::std::os::raw::c_int, - >, - pub vtab_on_conflict: - ::std::option::Option ::std::os::raw::c_int>, - pub close_v2: - ::std::option::Option ::std::os::raw::c_int>, - pub db_filename: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, - pub db_readonly: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub db_release_memory: - ::std::option::Option ::std::os::raw::c_int>, - pub errstr: ::std::option::Option< - unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, - >, - pub stmt_busy: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub stmt_readonly: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub stricmp: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub uri_boolean: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub uri_int64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_int64, - ) -> sqlite3_int64, - >, - pub uri_parameter: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> *const ::std::os::raw::c_char, - >, - pub xvsnprintf: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut __va_list_tag, - ) -> *mut ::std::os::raw::c_char, - >, - pub wal_checkpoint_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub auto_extension: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_blob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub bind_text64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - arg6: ::std::os::raw::c_uchar, - ) -> ::std::os::raw::c_int, - >, - pub cancel_auto_extension: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub load_extension: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub malloc64: ::std::option::Option< - unsafe extern "C" fn(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void, - >, - pub msize: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64, - >, - pub realloc64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: sqlite3_uint64, - ) -> *mut ::std::os::raw::c_void, - >, - pub reset_auto_extension: ::std::option::Option, - pub result_blob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - ), - >, - pub result_text64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - arg5: ::std::os::raw::c_uchar, - ), - >, - pub strglob: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub value_dup: ::std::option::Option< - unsafe extern "C" fn(arg1: *const sqlite3_value) -> *mut sqlite3_value, - >, - pub value_free: ::std::option::Option, - pub result_zeroblob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: sqlite3_uint64, - ) -> ::std::os::raw::c_int, - >, - pub bind_zeroblob64: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_uint64, - ) -> ::std::os::raw::c_int, - >, - pub value_subtype: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint, - >, - pub result_subtype: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint), - >, - pub status64: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut sqlite3_int64, - arg3: *mut sqlite3_int64, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub strlike: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_uint, - ) -> ::std::os::raw::c_int, - >, - pub db_cacheflush: - ::std::option::Option ::std::os::raw::c_int>, - pub system_errno: - ::std::option::Option ::std::os::raw::c_int>, - pub trace_v2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_uint, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_uint, - arg2: *mut ::std::os::raw::c_void, - arg3: *mut ::std::os::raw::c_void, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub expanded_sql: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char, - >, - pub set_last_insert_rowid: - ::std::option::Option, - pub prepare_v3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_uint, - arg5: *mut *mut sqlite3_stmt, - arg6: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub prepare16_v3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_uint, - arg5: *mut *mut sqlite3_stmt, - arg6: *mut *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - pub bind_pointer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: *const ::std::os::raw::c_char, - arg5: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub result_pointer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: *mut ::std::os::raw::c_void, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::option::Option, - ), - >, - pub value_pointer: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_value, - arg2: *const ::std::os::raw::c_char, - ) -> *mut ::std::os::raw::c_void, - >, - pub vtab_nochange: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, - >, - pub value_nochange: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub vtab_collation: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_index_info, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub keyword_count: ::std::option::Option ::std::os::raw::c_int>, - pub keyword_name: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_int, - arg2: *mut *const ::std::os::raw::c_char, - arg3: *mut ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub keyword_check: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - pub str_new: - ::std::option::Option *mut sqlite3_str>, - pub str_finish: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char, - >, - pub str_appendf: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_str, zFormat: *const ::std::os::raw::c_char, ...), - >, - pub str_vappendf: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_str, - zFormat: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, - ), - >, - pub str_append: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_str, - zIn: *const ::std::os::raw::c_char, - N: ::std::os::raw::c_int, - ), - >, - pub str_appendall: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_str, zIn: *const ::std::os::raw::c_char), - >, - pub str_appendchar: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_str, - N: ::std::os::raw::c_int, - C: ::std::os::raw::c_char, - ), - >, - pub str_reset: ::std::option::Option, - pub str_errcode: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int, - >, - pub str_length: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int, - >, - pub str_value: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char, - >, - pub create_window_function: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xValue: ::std::option::Option, - xInv: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xDestroy: ::std::option::Option, - ) -> ::std::os::raw::c_int, - >, - pub normalized_sql: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, - >, - pub stmt_isexplain: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, - >, - pub value_frombind: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, - >, - pub drop_modules: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3, - arg2: *mut *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - pub hard_heap_limit64: - ::std::option::Option sqlite3_int64>, - pub uri_key: ::std::option::Option< - unsafe extern "C" fn( - arg1: *const ::std::os::raw::c_char, - arg2: ::std::os::raw::c_int, - ) -> *const ::std::os::raw::c_char, - >, - pub filename_database: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char, - >, - pub filename_journal: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char, - >, - pub filename_wal: ::std::option::Option< - unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char, - >, -} -#[test] -fn bindgen_test_layout_sqlite3_api_routines() { - assert_eq!( - ::std::mem::size_of::(), - 1992usize, - concat!("Size of: ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(sqlite3_api_routines)) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_context as *const _ as usize - }, - 0usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_context) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).aggregate_count as *const _ as usize - }, - 8usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(aggregate_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_double as *const _ as usize - }, - 24usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, - 32usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_int64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, - 48usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_count as *const _ - as usize - }, - 56usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_index as *const _ - as usize - }, - 64usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_index) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_parameter_name as *const _ - as usize - }, - 72usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_parameter_name) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_text16 as *const _ as usize - }, - 88usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, - 96usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_handler as *const _ as usize - }, - 104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_handler) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).busy_timeout as *const _ as usize - }, - 112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(busy_timeout) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, - 120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, - 128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(close) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed as *const _ as usize - }, - 136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize - }, - 144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(collation_needed16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_blob as *const _ as usize - }, - 152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes as *const _ as usize - }, - 160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize - }, - 168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_count as *const _ as usize - }, - 176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name as *const _ - as usize - }, - 184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_database_name16 as *const _ - as usize - }, - 192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_database_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype as *const _ as usize - }, - 200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize - }, - 208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_decltype16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_double as *const _ as usize - }, - 216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, - 224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_int64 as *const _ as usize - }, - 232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name as *const _ as usize - }, - 240usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_name16 as *const _ as usize - }, - 248usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name as *const _ as usize - }, - 256usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_origin_name16 as *const _ - as usize - }, - 264usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_origin_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name as *const _ as usize - }, - 272usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_table_name16 as *const _ - as usize - }, - 280usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_table_name16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text as *const _ as usize - }, - 288usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_text16 as *const _ as usize - }, - 296usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_type as *const _ as usize - }, - 304usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_type) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).column_value as *const _ as usize - }, - 312usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(column_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).commit_hook as *const _ as usize - }, - 320usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(commit_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, - 328usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, - 336usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(complete16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation as *const _ as usize - }, - 344usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation16 as *const _ as usize - }, - 352usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function as *const _ as usize - }, - 360usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function16 as *const _ as usize - }, - 368usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module as *const _ as usize - }, - 376usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, - 384usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(data_count) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, - 392usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).declare_vtab as *const _ as usize - }, - 400usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(declare_vtab) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).enable_shared_cache as *const _ - as usize - }, - 408usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(enable_shared_cache) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, - 416usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, - 424usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, - 432usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errmsg16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, - 440usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(exec) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, - 448usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(expired) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, - 456usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(finalize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, - 464usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, - 472usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(free_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_autocommit as *const _ as usize - }, - 480usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_autocommit) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).get_auxdata as *const _ as usize - }, - 488usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, - 496usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(get_table) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).global_recover as *const _ as usize - }, - 504usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(global_recover) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, - 512usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(interruptx) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize - }, - 520usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(last_insert_rowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, - 528usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).libversion_number as *const _ as usize - }, - 536usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(libversion_number) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, - 544usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(malloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, - 552usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, - 560usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, - 568usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, - 576usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, - 584usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, - 592usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(profile) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).progress_handler as *const _ as usize - }, - 600usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(progress_handler) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, - 608usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(realloc) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, - 616usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(reset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_blob as *const _ as usize - }, - 624usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_double as *const _ as usize - }, - 632usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_double) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error as *const _ as usize - }, - 640usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error16 as *const _ as usize - }, - 648usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error16) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, - 656usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_int64 as *const _ as usize - }, - 664usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_null as *const _ as usize - }, - 672usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_null) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text as *const _ as usize - }, - 680usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16 as *const _ as usize - }, - 688usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16be as *const _ as usize - }, - 696usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text16le as *const _ as usize - }, - 704usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text16le) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_value as *const _ as usize - }, - 712usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).rollback_hook as *const _ as usize - }, - 720usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(rollback_hook) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_authorizer as *const _ as usize - }, - 728usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_authorizer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_auxdata as *const _ as usize - }, - 736usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_auxdata) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xsnprintf as *const _ as usize }, - 744usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(xsnprintf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, - 752usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(step) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).table_column_metadata as *const _ - as usize - }, - 760usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(table_column_metadata) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize - }, - 768usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(thread_cleanup) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).total_changes as *const _ as usize - }, - 776usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(total_changes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, - 784usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(trace) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize - }, - 792usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(transfer_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).update_hook as *const _ as usize - }, - 800usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(update_hook) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, - 808usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(user_data) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, - 816usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_blob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes as *const _ as usize - }, - 824usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize - }, - 832usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_bytes16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_double as *const _ as usize - }, - 840usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_double) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, - 848usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_int64 as *const _ as usize - }, - 856usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize - }, - 864usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_numeric_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, - 872usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16 as *const _ as usize - }, - 880usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16be as *const _ as usize - }, - 888usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16be) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_text16le as *const _ as usize - }, - 896usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_text16le) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, - 904usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_type) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, - 912usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vmprintf) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).overload_function as *const _ as usize - }, - 920usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(overload_function) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, - 928usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize - }, - 936usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).clear_bindings as *const _ as usize - }, - 944usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(clear_bindings) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize - }, - 952usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_module_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize - }, - 960usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_zeroblob) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, - 968usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_bytes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, - 976usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_close) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, - 984usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_open) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, - 992usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_read) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, - 1000usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_write) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_collation_v2 as *const _ - as usize - }, - 1008usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_collation_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).file_control as *const _ as usize - }, - 1016usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(file_control) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_highwater as *const _ as usize - }, - 1024usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_highwater) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).memory_used as *const _ as usize - }, - 1032usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(memory_used) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize - }, - 1040usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_alloc) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_enter as *const _ as usize - }, - 1048usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_enter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, - 1056usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_free) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).mutex_leave as *const _ as usize - }, - 1064usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_leave) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, - 1072usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(mutex_try) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, - 1080usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(open_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).release_memory as *const _ as usize - }, - 1088usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(release_memory) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize - }, - 1096usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_nomem) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_toobig as *const _ - as usize - }, - 1104usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_toobig) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, - 1112usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sleep) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize - }, - 1120usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(soft_heap_limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, - 1128usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_find) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_register as *const _ as usize - }, - 1136usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_register) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize - }, - 1144usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vfs_unregister) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize - }, - 1152usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(xthreadsafe) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize - }, - 1160usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_zeroblob) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_error_code as *const _ as usize - }, - 1168usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_error_code) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).test_control as *const _ as usize - }, - 1176usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(test_control) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, - 1184usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(randomness) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).context_db_handle as *const _ as usize - }, - 1192usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(context_db_handle) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).extended_result_codes as *const _ - as usize - }, - 1200usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(extended_result_codes) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, - 1208usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(limit) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, - 1216usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(next_stmt) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, - 1224usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sql) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, - 1232usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(status) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_finish as *const _ as usize - }, - 1240usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_finish) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_init as *const _ as usize - }, - 1248usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_init) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_pagecount as *const _ as usize - }, - 1256usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_pagecount) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_remaining as *const _ as usize - }, - 1264usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_remaining) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).backup_step as *const _ as usize - }, - 1272usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(backup_step) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).compileoption_get as *const _ as usize - }, - 1280usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(compileoption_get) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).compileoption_used as *const _ as usize - }, - 1288usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(compileoption_used) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_function_v2 as *const _ as usize - }, - 1296usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_function_v2) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_config as *const _ as usize }, - 1304usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_config) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_mutex as *const _ as usize }, - 1312usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_mutex) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).db_status as *const _ as usize }, - 1320usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_status) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).extended_errcode as *const _ as usize - }, - 1328usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(extended_errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).log as *const _ as usize }, - 1336usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(log) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).soft_heap_limit64 as *const _ as usize - }, - 1344usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(soft_heap_limit64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).sourceid as *const _ as usize }, - 1352usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(sourceid) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stmt_status as *const _ as usize - }, - 1360usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_status) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).strnicmp as *const _ as usize }, - 1368usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(strnicmp) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).unlock_notify as *const _ as usize - }, - 1376usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(unlock_notify) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_autocheckpoint as *const _ as usize - }, - 1384usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_autocheckpoint) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_checkpoint as *const _ as usize - }, - 1392usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_checkpoint) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).wal_hook as *const _ as usize }, - 1400usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_hook) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).blob_reopen as *const _ as usize - }, - 1408usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(blob_reopen) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtab_config as *const _ as usize - }, - 1416usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vtab_config) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtab_on_conflict as *const _ as usize - }, - 1424usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vtab_on_conflict) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).close_v2 as *const _ as usize }, - 1432usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(close_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_filename as *const _ as usize - }, - 1440usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_filename) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_readonly as *const _ as usize - }, - 1448usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_readonly) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_release_memory as *const _ as usize - }, - 1456usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_release_memory) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).errstr as *const _ as usize }, - 1464usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(errstr) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).stmt_busy as *const _ as usize }, - 1472usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_busy) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stmt_readonly as *const _ as usize - }, - 1480usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_readonly) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).stricmp as *const _ as usize }, - 1488usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stricmp) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).uri_boolean as *const _ as usize - }, - 1496usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(uri_boolean) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).uri_int64 as *const _ as usize }, - 1504usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(uri_int64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).uri_parameter as *const _ as usize - }, - 1512usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(uri_parameter) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).xvsnprintf as *const _ as usize }, - 1520usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(xvsnprintf) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).wal_checkpoint_v2 as *const _ as usize - }, - 1528usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(wal_checkpoint_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).auto_extension as *const _ as usize - }, - 1536usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(auto_extension) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_blob64 as *const _ as usize - }, - 1544usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_blob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_text64 as *const _ as usize - }, - 1552usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_text64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).cancel_auto_extension as *const _ - as usize - }, - 1560usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(cancel_auto_extension) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).load_extension as *const _ as usize - }, - 1568usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(load_extension) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).malloc64 as *const _ as usize }, - 1576usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(malloc64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).msize as *const _ as usize }, - 1584usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(msize) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).realloc64 as *const _ as usize }, - 1592usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(realloc64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).reset_auto_extension as *const _ - as usize - }, - 1600usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(reset_auto_extension) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_blob64 as *const _ as usize - }, - 1608usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_blob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_text64 as *const _ as usize - }, - 1616usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_text64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).strglob as *const _ as usize }, - 1624usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(strglob) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_dup as *const _ as usize }, - 1632usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_dup) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).value_free as *const _ as usize }, - 1640usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_free) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_zeroblob64 as *const _ as usize - }, - 1648usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_zeroblob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_zeroblob64 as *const _ as usize - }, - 1656usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_zeroblob64) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_subtype as *const _ as usize - }, - 1664usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_subtype) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_subtype as *const _ as usize - }, - 1672usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_subtype) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).status64 as *const _ as usize }, - 1680usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(status64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).strlike as *const _ as usize }, - 1688usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(strlike) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).db_cacheflush as *const _ as usize - }, - 1696usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(db_cacheflush) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).system_errno as *const _ as usize - }, - 1704usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(system_errno) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).trace_v2 as *const _ as usize }, - 1712usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(trace_v2) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).expanded_sql as *const _ as usize - }, - 1720usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(expanded_sql) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).set_last_insert_rowid as *const _ - as usize - }, - 1728usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(set_last_insert_rowid) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).prepare_v3 as *const _ as usize }, - 1736usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare_v3) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).prepare16_v3 as *const _ as usize - }, - 1744usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(prepare16_v3) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).bind_pointer as *const _ as usize - }, - 1752usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(bind_pointer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).result_pointer as *const _ as usize - }, - 1760usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(result_pointer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_pointer as *const _ as usize - }, - 1768usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_pointer) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtab_nochange as *const _ as usize - }, - 1776usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vtab_nochange) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_nochange as *const _ as usize - }, - 1784usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_nochange) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).vtab_collation as *const _ as usize - }, - 1792usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vtab_collation) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).keyword_count as *const _ as usize - }, - 1800usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(keyword_count) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).keyword_name as *const _ as usize - }, - 1808usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(keyword_name) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).keyword_check as *const _ as usize - }, - 1816usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(keyword_check) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).str_new as *const _ as usize }, - 1824usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_new) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).str_finish as *const _ as usize }, - 1832usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_finish) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).str_appendf as *const _ as usize - }, - 1840usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_appendf) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).str_vappendf as *const _ as usize - }, - 1848usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_vappendf) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).str_append as *const _ as usize }, - 1856usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_append) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).str_appendall as *const _ as usize - }, - 1864usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_appendall) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).str_appendchar as *const _ as usize - }, - 1872usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_appendchar) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).str_reset as *const _ as usize }, - 1880usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_reset) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).str_errcode as *const _ as usize - }, - 1888usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_errcode) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).str_length as *const _ as usize }, - 1896usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_length) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).str_value as *const _ as usize }, - 1904usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(str_value) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).create_window_function as *const _ - as usize - }, - 1912usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(create_window_function) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).normalized_sql as *const _ as usize - }, - 1920usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(normalized_sql) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).stmt_isexplain as *const _ as usize - }, - 1928usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(stmt_isexplain) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).value_frombind as *const _ as usize - }, - 1936usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(value_frombind) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).drop_modules as *const _ as usize - }, - 1944usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(drop_modules) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).hard_heap_limit64 as *const _ as usize - }, - 1952usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(hard_heap_limit64) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).uri_key as *const _ as usize }, - 1960usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(uri_key) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).filename_database as *const _ as usize - }, - 1968usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(filename_database) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).filename_journal as *const _ as usize - }, - 1976usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(filename_journal) - ) - ); - assert_eq!( - unsafe { - &(*(::std::ptr::null::())).filename_wal as *const _ as usize - }, - 1984usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(filename_wal) - ) - ); -} -pub type sqlite3_loadext_entry = ::std::option::Option< - unsafe extern "C" fn( - db: *mut sqlite3, - pzErrMsg: *mut *mut ::std::os::raw::c_char, - pThunk: *const sqlite3_api_routines, - ) -> ::std::os::raw::c_int, ->; -pub type __builtin_va_list = [__va_list_tag; 1usize]; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct __va_list_tag { - pub gp_offset: ::std::os::raw::c_uint, - pub fp_offset: ::std::os::raw::c_uint, - pub overflow_arg_area: *mut ::std::os::raw::c_void, - pub reg_save_area: *mut ::std::os::raw::c_void, -} -#[test] -fn bindgen_test_layout___va_list_tag() { - assert_eq!( - ::std::mem::size_of::<__va_list_tag>(), - 24usize, - concat!("Size of: ", stringify!(__va_list_tag)) - ); - assert_eq!( - ::std::mem::align_of::<__va_list_tag>(), - 8usize, - concat!("Alignment of ", stringify!(__va_list_tag)) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(gp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(fp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(overflow_arg_area) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(reg_save_area) - ) - ); -} - -// bindings were built with loadable_extension_embedded: -// define sqlite3_api as an extern since this code will be embedded -// within a loadable extension that defines and exports this itself -extern "C" { - #[no_mangle] - pub static mut sqlite3_api: *mut sqlite3_api_routines; -} - -// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) - -pub unsafe fn sqlite3_aggregate_context( - arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_context.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_context", - " function" - )))(arg1, nBytes) -} - -pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "aggregate_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_blob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_blob", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_double( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: f64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_double", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_int64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite_int64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_int64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_bind_null( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_null", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_count", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_parameter_index( - arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_index.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_index", - " function" - )))(arg1, zName) -} - -pub unsafe fn sqlite3_bind_parameter_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_parameter_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_text( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text", - " function" - )))(arg1, arg2, arg3, n, arg4) -} - -pub unsafe fn sqlite3_bind_text16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_bind_value( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_value", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_handler( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_handler", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_busy_timeout( - arg1: *mut sqlite3, - ms: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_timeout.expect(stringify!( - "sqlite3_api contains null pointer for ", - "busy_timeout", - " function" - )))(arg1, ms) -} - -pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_collation_needed( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_collation_needed16( - arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - eTextRep: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - ), - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "collation_needed16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_column_blob( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_blob", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_bytes16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_bytes16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_column_database_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_database_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_database_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_decltype( - arg1: *mut sqlite3_stmt, - i: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype", - " function" - )))(arg1, i) -} - -pub unsafe fn sqlite3_column_decltype16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_decltype16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_double", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_int64( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_int64", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_origin_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_origin_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_table_name16( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_table_name16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_column_text( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_text16( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_text16", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_type( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_type", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_column_value( - arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int, -) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "column_value", - " function" - )))(arg1, iCol) -} - -pub unsafe fn sqlite3_commit_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).commit_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "commit_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "complete16", - " function" - )))(sql) -} - -pub unsafe fn sqlite3_create_collation( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_collation16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_create_function( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_function16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function16", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) -} - -pub unsafe fn sqlite3_create_module( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).data_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "data_count", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_declare_vtab( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).declare_vtab.expect(stringify!( - "sqlite3_api contains null pointer for ", - "declare_vtab", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).enable_shared_cache.expect(stringify!( - "sqlite3_api contains null pointer for ", - "enable_shared_cache", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errcode", - " function" - )))(db) -} - -pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errmsg16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_exec( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_callback, - arg4: *mut ::std::os::raw::c_void, - arg5: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).exec.expect(stringify!( - "sqlite3_api contains null pointer for ", - "exec", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).expired.expect(stringify!( - "sqlite3_api contains null pointer for ", - "expired", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).finalize.expect(stringify!( - "sqlite3_api contains null pointer for ", - "finalize", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "free_table", - " function" - )))(result) -} - -pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_autocommit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_autocommit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_get_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_auxdata", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_get_table( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut *mut *mut ::std::os::raw::c_char, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, - arg6: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_table.expect(stringify!( - "sqlite3_api contains null pointer for ", - "get_table", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).global_recover.expect(stringify!( - "sqlite3_api contains null pointer for ", - "global_recover", - " function" - )))() -} - -pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).interruptx.expect(stringify!( - "sqlite3_api contains null pointer for ", - "interruptx", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).last_insert_rowid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "last_insert_rowid", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion", - " function" - )))() -} - -pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion_number.expect(stringify!( - "sqlite3_api contains null pointer for ", - "libversion_number", - " function" - )))() -} - -pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).malloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "malloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mprintf( - arg1: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mprintf", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_open( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_open16( - arg1: *const ::std::os::raw::c_void, - arg2: *mut *mut sqlite3, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open16", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_prepare( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_profile( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite_uint64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).profile.expect(stringify!( - "sqlite3_api contains null pointer for ", - "profile", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_progress_handler( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).progress_handler.expect(stringify!( - "sqlite3_api contains null pointer for ", - "progress_handler", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_realloc( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).realloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "realloc", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).reset.expect(stringify!( - "sqlite3_api contains null pointer for ", - "reset", - " function" - )))(pStmt) -} - -pub unsafe fn sqlite3_result_blob( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_blob", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_double", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_error16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error16", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_int64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_null.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_null", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_text( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16be( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16be", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text16le( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text16le", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_value", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_rollback_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).rollback_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "rollback_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_authorizer( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *const ::std::os::raw::c_char, - arg6: *const ::std::os::raw::c_char, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_authorizer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_authorizer", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_set_auxdata( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_auxdata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_auxdata", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_xsnprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).xsnprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "xsnprintf", - " function" - )))(arg1, arg2, arg3, vararg1) -} - -pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).step.expect(stringify!( - "sqlite3_api contains null pointer for ", - "step", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_table_column_metadata( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: *mut *const ::std::os::raw::c_char, - arg6: *mut *const ::std::os::raw::c_char, - arg7: *mut ::std::os::raw::c_int, - arg8: *mut ::std::os::raw::c_int, - arg9: *mut ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).table_column_metadata.expect(stringify!( - "sqlite3_api contains null pointer for ", - "table_column_metadata", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) -} - -pub unsafe fn sqlite3_thread_cleanup() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).thread_cleanup.expect(stringify!( - "sqlite3_api contains null pointer for ", - "thread_cleanup", - " function" - )))() -} - -pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).total_changes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "total_changes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_trace( - arg1: *mut sqlite3, - xTrace: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *const ::std::os::raw::c_char, - ), - >, - arg2: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).trace.expect(stringify!( - "sqlite3_api contains null pointer for ", - "trace", - " function" - )))(arg1, xTrace, arg2) -} - -pub unsafe fn sqlite3_transfer_bindings( - arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).transfer_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "transfer_bindings", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_update_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite_int64, - ), - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).update_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "update_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).user_data.expect(stringify!( - "sqlite3_api contains null pointer for ", - "user_data", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_blob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_blob", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_bytes16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_double.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_double", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_int64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_numeric_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_numeric_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16be.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16be", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16le.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_text16le", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_type.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_type", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vmprintf( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vmprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vmprintf", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_overload_function( - arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).overload_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "overload_function", - " function" - )))(arg1, zFuncName, nArg) -} - -pub unsafe fn sqlite3_prepare_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_prepare16_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: *mut *mut sqlite3_stmt, - arg5: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).clear_bindings.expect(stringify!( - "sqlite3_api contains null pointer for ", - "clear_bindings", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_module_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const sqlite3_module, - arg4: *mut ::std::os::raw::c_void, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_module_v2", - " function" - )))(arg1, arg2, arg3, arg4, xDestroy) -} - -pub unsafe fn sqlite3_bind_zeroblob( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_zeroblob", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_bytes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_bytes", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_close.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_close", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_blob_open( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *const ::std::os::raw::c_char, - arg5: sqlite3_int64, - arg6: ::std::os::raw::c_int, - arg7: *mut *mut sqlite3_blob, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_open.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_open", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) -} - -pub unsafe fn sqlite3_blob_read( - arg1: *mut sqlite3_blob, - arg2: *mut ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_read.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_read", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_blob_write( - arg1: *mut sqlite3_blob, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_write.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_write", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_create_collation_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, - arg5: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: *const ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg6: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_collation_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_file_control( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).file_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "file_control", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_highwater.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_highwater", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).memory_used.expect(stringify!( - "sqlite3_api contains null pointer for ", - "memory_used", - " function" - )))() -} - -pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_alloc.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_alloc", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_enter.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_enter", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_leave.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_leave", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mutex_try.expect(stringify!( - "sqlite3_api contains null pointer for ", - "mutex_try", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_open_v2( - arg1: *const ::std::os::raw::c_char, - arg2: *mut *mut sqlite3, - arg3: ::std::os::raw::c_int, - arg4: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "open_v2", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).release_memory.expect(stringify!( - "sqlite3_api contains null pointer for ", - "release_memory", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_nomem.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_nomem", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_toobig.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_toobig", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sleep.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sleep", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).soft_heap_limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "soft_heap_limit", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_find.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_find", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vfs_register( - arg1: *mut sqlite3_vfs, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_register.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_register", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vfs_unregister.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vfs_unregister", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).xthreadsafe.expect(stringify!( - "sqlite3_api contains null pointer for ", - "xthreadsafe", - " function" - )))() -} - -pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_zeroblob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_zeroblob", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error_code.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_error_code", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_test_control( - arg1: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).test_control.expect(stringify!( - "sqlite3_api contains null pointer for ", - "test_control", - " function" - )))(arg1, vararg1) -} - -pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).randomness.expect(stringify!( - "sqlite3_api contains null pointer for ", - "randomness", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).context_db_handle.expect(stringify!( - "sqlite3_api contains null pointer for ", - "context_db_handle", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_extended_result_codes( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).extended_result_codes.expect(stringify!( - "sqlite3_api contains null pointer for ", - "extended_result_codes", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_limit( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).limit.expect(stringify!( - "sqlite3_api contains null pointer for ", - "limit", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).next_stmt.expect(stringify!( - "sqlite3_api contains null pointer for ", - "next_stmt", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sql.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sql", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_status( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "status", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_finish.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_finish", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_init( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *mut sqlite3, - arg4: *const ::std::os::raw::c_char, -) -> *mut sqlite3_backup { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_init.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_init", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_pagecount.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_pagecount", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_remaining.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_remaining", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_backup_step( - arg1: *mut sqlite3_backup, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).backup_step.expect(stringify!( - "sqlite3_api contains null pointer for ", - "backup_step", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_compileoption_get( - arg1: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).compileoption_get.expect(stringify!( - "sqlite3_api contains null pointer for ", - "compileoption_get", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_compileoption_used( - arg1: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).compileoption_used.expect(stringify!( - "sqlite3_api contains null pointer for ", - "compileoption_used", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_function_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xFunc: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_function_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal, xDestroy) -} - -pub unsafe fn sqlite3_db_config( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, - vararg2: &mut i32, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_config.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_config", - " function" - )))(arg1, arg2, vararg1, vararg2) -} - -pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_mutex.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_mutex", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_db_status( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_status", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).extended_errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "extended_errcode", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_log( - arg1: ::std::os::raw::c_int, - arg2: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).log.expect(stringify!( - "sqlite3_api contains null pointer for ", - "log", - " function" - )))(arg1, arg2, vararg1) -} - -pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).soft_heap_limit64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "soft_heap_limit64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).sourceid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "sourceid", - " function" - )))() -} - -pub unsafe fn sqlite3_stmt_status( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_status.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_status", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_strnicmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).strnicmp.expect(stringify!( - "sqlite3_api contains null pointer for ", - "strnicmp", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_unlock_notify( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn(arg1: *mut *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int), - >, - arg3: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).unlock_notify.expect(stringify!( - "sqlite3_api contains null pointer for ", - "unlock_notify", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_wal_autocheckpoint( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_autocheckpoint", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_wal_checkpoint( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_checkpoint.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_checkpoint", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_wal_hook( - arg1: *mut sqlite3, - arg2: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut ::std::os::raw::c_void, - arg2: *mut sqlite3, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::os::raw::c_int, - ) -> ::std::os::raw::c_int, - >, - arg3: *mut ::std::os::raw::c_void, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_hook.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_hook", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_blob_reopen( - arg1: *mut sqlite3_blob, - arg2: sqlite3_int64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).blob_reopen.expect(stringify!( - "sqlite3_api contains null pointer for ", - "blob_reopen", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vtab_config( - arg1: *mut sqlite3, - op: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vtab_config.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vtab_config", - " function" - )))(arg1, op, vararg1) -} - -pub unsafe fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vtab_on_conflict.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vtab_on_conflict", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "close_v2", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_db_filename( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_filename.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_filename", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_db_readonly( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_readonly.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_readonly", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_release_memory.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_release_memory", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errstr.expect(stringify!( - "sqlite3_api contains null pointer for ", - "errstr", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_busy.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_busy", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_stmt_readonly(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_readonly.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_readonly", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_stricmp( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stricmp.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stricmp", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_uri_boolean( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).uri_boolean.expect(stringify!( - "sqlite3_api contains null pointer for ", - "uri_boolean", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_uri_int64( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_int64, -) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).uri_int64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "uri_int64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_uri_parameter( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).uri_parameter.expect(stringify!( - "sqlite3_api contains null pointer for ", - "uri_parameter", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_xvsnprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut __va_list_tag, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).xvsnprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "xvsnprintf", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_wal_checkpoint_v2( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: *mut ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).wal_checkpoint_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "wal_checkpoint_v2", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_auto_extension( - arg1: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).auto_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "auto_extension", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_bind_blob64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_blob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_blob64", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_bind_text64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - arg4: sqlite3_uint64, - arg5: ::std::option::Option, - arg6: ::std::os::raw::c_uchar, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_text64", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_cancel_auto_extension( - arg1: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).cancel_auto_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "cancel_auto_extension", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_load_extension( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut *mut ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).load_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "load_extension", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_malloc64(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).malloc64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "malloc64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_msize(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).msize.expect(stringify!( - "sqlite3_api contains null pointer for ", - "msize", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_realloc64( - arg1: *mut ::std::os::raw::c_void, - arg2: sqlite3_uint64, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).realloc64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "realloc64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_reset_auto_extension() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).reset_auto_extension.expect(stringify!( - "sqlite3_api contains null pointer for ", - "reset_auto_extension", - " function" - )))() -} - -pub unsafe fn sqlite3_result_blob64( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_blob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_blob64", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_result_text64( - arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_uint64, - arg4: ::std::option::Option, - arg5: ::std::os::raw::c_uchar, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_text64", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_strglob( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).strglob.expect(stringify!( - "sqlite3_api contains null pointer for ", - "strglob", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_value_dup(arg1: *const sqlite3_value) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_dup.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_dup", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_free(arg1: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_free.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_free", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_zeroblob64( - arg1: *mut sqlite3_context, - arg2: sqlite3_uint64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_zeroblob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_zeroblob64", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_bind_zeroblob64( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_uint64, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_zeroblob64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_zeroblob64", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_value_subtype(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_subtype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_subtype", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_result_subtype(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_subtype.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_subtype", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_status64( - arg1: ::std::os::raw::c_int, - arg2: *mut sqlite3_int64, - arg3: *mut sqlite3_int64, - arg4: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).status64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "status64", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_strlike( - arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_uint, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).strlike.expect(stringify!( - "sqlite3_api contains null pointer for ", - "strlike", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_db_cacheflush(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_cacheflush.expect(stringify!( - "sqlite3_api contains null pointer for ", - "db_cacheflush", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_system_errno(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).system_errno.expect(stringify!( - "sqlite3_api contains null pointer for ", - "system_errno", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_trace_v2( - arg1: *mut sqlite3, - arg2: ::std::os::raw::c_uint, - arg3: ::std::option::Option< - unsafe extern "C" fn( - arg1: ::std::os::raw::c_uint, - arg2: *mut ::std::os::raw::c_void, - arg3: *mut ::std::os::raw::c_void, - arg4: *mut ::std::os::raw::c_void, - ) -> ::std::os::raw::c_int, - >, - arg4: *mut ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).trace_v2.expect(stringify!( - "sqlite3_api contains null pointer for ", - "trace_v2", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_expanded_sql(arg1: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).expanded_sql.expect(stringify!( - "sqlite3_api contains null pointer for ", - "expanded_sql", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_set_last_insert_rowid(arg1: *mut sqlite3, arg2: sqlite3_int64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_last_insert_rowid.expect(stringify!( - "sqlite3_api contains null pointer for ", - "set_last_insert_rowid", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_prepare_v3( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_uint, - arg5: *mut *mut sqlite3_stmt, - arg6: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare_v3.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare_v3", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_prepare16_v3( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_uint, - arg5: *mut *mut sqlite3_stmt, - arg6: *mut *const ::std::os::raw::c_void, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16_v3.expect(stringify!( - "sqlite3_api contains null pointer for ", - "prepare16_v3", - " function" - )))(arg1, arg2, arg3, arg4, arg5, arg6) -} - -pub unsafe fn sqlite3_bind_pointer( - arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *mut ::std::os::raw::c_void, - arg4: *const ::std::os::raw::c_char, - arg5: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_pointer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "bind_pointer", - " function" - )))(arg1, arg2, arg3, arg4, arg5) -} - -pub unsafe fn sqlite3_result_pointer( - arg1: *mut sqlite3_context, - arg2: *mut ::std::os::raw::c_void, - arg3: *const ::std::os::raw::c_char, - arg4: ::std::option::Option, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_pointer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "result_pointer", - " function" - )))(arg1, arg2, arg3, arg4) -} - -pub unsafe fn sqlite3_value_pointer( - arg1: *mut sqlite3_value, - arg2: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_pointer.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_pointer", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_vtab_nochange(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vtab_nochange.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vtab_nochange", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_nochange(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_nochange.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_nochange", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_vtab_collation( - arg1: *mut sqlite3_index_info, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vtab_collation.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vtab_collation", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_keyword_count() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).keyword_count.expect(stringify!( - "sqlite3_api contains null pointer for ", - "keyword_count", - " function" - )))() -} - -pub unsafe fn sqlite3_keyword_name( - arg1: ::std::os::raw::c_int, - arg2: *mut *const ::std::os::raw::c_char, - arg3: *mut ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).keyword_name.expect(stringify!( - "sqlite3_api contains null pointer for ", - "keyword_name", - " function" - )))(arg1, arg2, arg3) -} - -pub unsafe fn sqlite3_keyword_check( - arg1: *const ::std::os::raw::c_char, - arg2: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).keyword_check.expect(stringify!( - "sqlite3_api contains null pointer for ", - "keyword_check", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_str_new(arg1: *mut sqlite3) -> *mut sqlite3_str { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_new.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_new", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_str_finish(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_finish.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_finish", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_str_appendf( - arg1: *mut sqlite3_str, - zFormat: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_appendf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_appendf", - " function" - )))(arg1, zFormat, vararg1) -} - -pub unsafe fn sqlite3_str_vappendf( - arg1: *mut sqlite3_str, - zFormat: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_vappendf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_vappendf", - " function" - )))(arg1, zFormat, arg2) -} - -pub unsafe fn sqlite3_str_append( - arg1: *mut sqlite3_str, - zIn: *const ::std::os::raw::c_char, - N: ::std::os::raw::c_int, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_append.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_append", - " function" - )))(arg1, zIn, N) -} - -pub unsafe fn sqlite3_str_appendall(arg1: *mut sqlite3_str, zIn: *const ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_appendall.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_appendall", - " function" - )))(arg1, zIn) -} - -pub unsafe fn sqlite3_str_appendchar( - arg1: *mut sqlite3_str, - N: ::std::os::raw::c_int, - C: ::std::os::raw::c_char, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_appendchar.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_appendchar", - " function" - )))(arg1, N, C) -} - -pub unsafe fn sqlite3_str_reset(arg1: *mut sqlite3_str) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_reset.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_reset", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_str_errcode(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_errcode.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_errcode", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_str_length(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_length.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_length", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_str_value(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_value.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_value", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_create_window_function( - arg1: *mut sqlite3, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: ::std::os::raw::c_int, - arg5: *mut ::std::os::raw::c_void, - xStep: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xFinal: ::std::option::Option, - xValue: ::std::option::Option, - xInv: ::std::option::Option< - unsafe extern "C" fn( - arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int, - arg3: *mut *mut sqlite3_value, - ), - >, - xDestroy: ::std::option::Option, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_window_function.expect(stringify!( - "sqlite3_api contains null pointer for ", - "create_window_function", - " function" - )))( - arg1, arg2, arg3, arg4, arg5, xStep, xFinal, xValue, xInv, xDestroy, - ) -} - -pub unsafe fn sqlite3_normalized_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).normalized_sql.expect(stringify!( - "sqlite3_api contains null pointer for ", - "normalized_sql", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_stmt_isexplain(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).stmt_isexplain.expect(stringify!( - "sqlite3_api contains null pointer for ", - "stmt_isexplain", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_value_frombind(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_frombind.expect(stringify!( - "sqlite3_api contains null pointer for ", - "value_frombind", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_drop_modules( - arg1: *mut sqlite3, - arg2: *mut *const ::std::os::raw::c_char, -) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).drop_modules.expect(stringify!( - "sqlite3_api contains null pointer for ", - "drop_modules", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_hard_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).hard_heap_limit64.expect(stringify!( - "sqlite3_api contains null pointer for ", - "hard_heap_limit64", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_uri_key( - arg1: *const ::std::os::raw::c_char, - arg2: ::std::os::raw::c_int, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).uri_key.expect(stringify!( - "sqlite3_api contains null pointer for ", - "uri_key", - " function" - )))(arg1, arg2) -} - -pub unsafe fn sqlite3_filename_database( - arg1: *const ::std::os::raw::c_char, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).filename_database.expect(stringify!( - "sqlite3_api contains null pointer for ", - "filename_database", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_filename_journal( - arg1: *const ::std::os::raw::c_char, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).filename_journal.expect(stringify!( - "sqlite3_api contains null pointer for ", - "filename_journal", - " function" - )))(arg1) -} - -pub unsafe fn sqlite3_filename_wal( - arg1: *const ::std::os::raw::c_char, -) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).filename_wal.expect(stringify!( - "sqlite3_api contains null pointer for ", - "filename_wal", - " function" - )))(arg1) -} diff --git a/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs b/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs index 99b82f013..24f0aa4ab 100644 --- a/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs +++ b/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs @@ -7895,12 +7895,6 @@ fn bindgen_test_layout___va_list_tag() { ); } -// bindings were built with (non-embedded) loadable_extension: -// we define our own sqlite_api static variable and export it -// to C -#[no_mangle] -pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_routines; - // sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) pub unsafe fn sqlite3_aggregate_context( diff --git a/libsqlite3-sys/src/lib.rs b/libsqlite3-sys/src/lib.rs index 82fcc2619..34658e7ee 100644 --- a/libsqlite3-sys/src/lib.rs +++ b/libsqlite3-sys/src/lib.rs @@ -49,6 +49,23 @@ pub enum Limit { SQLITE_LIMIT_WORKER_THREADS = 11, } +#[cfg(feature = "loadable_extension_embedded")] +// bindings were built with loadable_extension_embedded: +// define sqlite3_api as an extern since this code will be embedded +// within a loadable extension that defines and exports this itself +extern { + #[no_mangle] + pub static mut sqlite3_api: *mut sqlite3_api_routines; +} + +#[cfg(all(feature = "loadable_extension", not(feature = "loadable_extension_embedded")))] +// bindings were built with (non-embedded) loadable_extension: +// we define our own (i.e. not extern) sqlite_api static +// variable and export it publicly so that it is included in +// our FFI (C) interface. +#[no_mangle] +pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_routines; + #[allow(clippy::all)] mod bindings { include!(concat!(env!("OUT_DIR"), "/bindgen.rs")); diff --git a/libsqlite3-sys/upgrade.sh b/libsqlite3-sys/upgrade.sh index 4cfd9a061..202337b5c 100755 --- a/libsqlite3-sys/upgrade.sh +++ b/libsqlite3-sys/upgrade.sh @@ -31,7 +31,6 @@ function generate_bindgen_binding() { generate_bindgen_binding "buildtime_bindgen" $SQLITE3_LIB_DIR/bindgen_bundled_version.rs generate_bindgen_binding "buildtime_bindgen,loadable_extension" $SQLITE3_LIB_DIR/bindgen_bundled_version-ext.rs -generate_bindgen_binding "buildtime_bindgen,loadable_extension_embedded" $SQLITE3_LIB_DIR/bindgen_bundled_version-ext-embed.rs # Sanity check cd $SCRIPT_DIR/.. diff --git a/src/error.rs b/src/error.rs index 5a64cfe38..a1c6e8289 100644 --- a/src/error.rs +++ b/src/error.rs @@ -351,6 +351,10 @@ pub fn error_from_handle(db: *mut ffi::sqlite3, code: c_int) -> Error { error_from_sqlite_code(code, message) } +#[cfg(not(any( + feature = "loadable_extension", + feature = "loadable_extension_embedded" +)))] macro_rules! check { ($funcall:expr) => {{ let rc = $funcall; From d52a9202735373ddd9a42c23190af74c92ee35ac Mon Sep 17 00:00:00 2001 From: gwenn Date: Sun, 8 Mar 2020 10:18:41 +0100 Subject: [PATCH 29/61] Fix bindgen_bundled_version-ext.rs --- libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs b/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs index 24f0aa4ab..e8adc85df 100644 --- a/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs +++ b/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs @@ -7895,6 +7895,10 @@ fn bindgen_test_layout___va_list_tag() { ); } +// sqlite3_api is defined in lib.rs as either a static or an extern when compiled as a loadable_extension +#[cfg(feature = "loadable_extension")] +use crate::sqlite3_api; + // sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) pub unsafe fn sqlite3_aggregate_context( From db04c939c340fc95a6de024b4619b2e38ea2a8c5 Mon Sep 17 00:00:00 2001 From: gwenn Date: Sun, 8 Mar 2020 10:19:33 +0100 Subject: [PATCH 30/61] Add comments --- Cargo.toml | 1 + libsqlite3-sys/Cargo.toml | 2 ++ 2 files changed, 3 insertions(+) diff --git a/Cargo.toml b/Cargo.toml index 61a1622cb..5dd88bd9b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -40,6 +40,7 @@ loadable_extension_embedded = ["libsqlite3-sys/loadable_extension_embedded"] limits = [] hooks = [] i128_blob = ["byteorder"] +# when `sqlcipher` is used, `bundled` and `loadable_extension` are ignored sqlcipher = ["libsqlite3-sys/sqlcipher"] unlock_notify = ["libsqlite3-sys/unlock_notify"] # xSavepoint, xRelease and xRollbackTo: 3.7.7 (2011-06-23) diff --git a/libsqlite3-sys/Cargo.toml b/libsqlite3-sys/Cargo.toml index 4759e8fe1..a46d4ebca 100644 --- a/libsqlite3-sys/Cargo.toml +++ b/libsqlite3-sys/Cargo.toml @@ -14,10 +14,12 @@ categories = ["external-ffi-bindings"] [features] default = ["min_sqlite_version_3_6_8"] bundled = ["cc", "bundled_bindings"] +# allows a dependency to use `bundled` only on windows bundled-windows = ["cc", "bundled_bindings"] buildtime_bindgen = ["bindgen", "pkg-config", "vcpkg"] loadable_extension = ["syn", "quote"] loadable_extension_embedded = ["loadable_extension"] +# when `sqlcipher` is used, `bundled` and `loadable_extension` are ignored sqlcipher = [] min_sqlite_version_3_6_8 = ["pkg-config", "vcpkg"] min_sqlite_version_3_7_16 = ["pkg-config", "vcpkg"] From f3b58e160bdbb227a9966190a201e477e83d7894 Mon Sep 17 00:00:00 2001 From: gwenn Date: Sun, 8 Mar 2020 11:54:57 +0100 Subject: [PATCH 31/61] `config_log` cannot be used with `loadable_extension` --- src/error.rs | 4 ---- src/trace.rs | 22 ++++++++++++++++------ tests/config_log.rs | 14 ++++++++++++-- 3 files changed, 28 insertions(+), 12 deletions(-) diff --git a/src/error.rs b/src/error.rs index a1c6e8289..5a64cfe38 100644 --- a/src/error.rs +++ b/src/error.rs @@ -351,10 +351,6 @@ pub fn error_from_handle(db: *mut ffi::sqlite3, code: c_int) -> Error { error_from_sqlite_code(code, message) } -#[cfg(not(any( - feature = "loadable_extension", - feature = "loadable_extension_embedded" -)))] macro_rules! check { ($funcall:expr) => {{ let rc = $funcall; diff --git a/src/trace.rs b/src/trace.rs index 1ccc55f1f..fb783c784 100644 --- a/src/trace.rs +++ b/src/trace.rs @@ -1,15 +1,14 @@ //! Tracing and profiling functions. Error and warning log. -use std::ffi::{CStr, CString}; +use std::ffi::CStr; use std::mem; -use std::os::raw::{c_char, c_int, c_void}; +use std::os::raw::{c_char, c_void}; use std::panic::catch_unwind; use std::ptr; use std::time::Duration; use super::ffi; -use crate::error::error_from_sqlite_code; -use crate::{Connection, Result}; +use crate::Connection; /// Set up the process-wide SQLite error logging callback. /// @@ -25,7 +24,13 @@ use crate::{Connection, Result}; /// * It must be threadsafe if SQLite is used in a multithreaded way. /// /// cf [The Error And Warning Log](http://sqlite.org/errlog.html). -pub unsafe fn config_log(callback: Option) -> Result<()> { +#[cfg(not(any( + feature = "loadable_extension", + feature = "loadable_extension_embedded" +)))] +pub unsafe fn config_log(callback: Option) -> crate::Result<()> { + use crate::error::error_from_sqlite_code; + use std::os::raw::c_int; extern "C" fn log_callback(p_arg: *mut c_void, err: c_int, msg: *const c_char) { let c_slice = unsafe { CStr::from_ptr(msg).to_bytes() }; let callback: fn(c_int, &str) = unsafe { mem::transmute(p_arg) }; @@ -57,7 +62,12 @@ pub unsafe fn config_log(callback: Option) -> Result<()> { } /// Write a message into the error log established by `config_log`. -pub fn log(err_code: c_int, msg: &str) { +#[cfg(not(any( + feature = "loadable_extension", + feature = "loadable_extension_embedded" +)))] +pub fn log(err_code: std::os::raw::c_int, msg: &str) { + use std::ffi::CString; let msg = CString::new(msg).expect("SQLite log messages cannot contain embedded zeroes"); unsafe { ffi::sqlite3_log(err_code, msg.as_ptr()); diff --git a/tests/config_log.rs b/tests/config_log.rs index 0c28bdf1d..db487c1a8 100644 --- a/tests/config_log.rs +++ b/tests/config_log.rs @@ -2,7 +2,13 @@ //! function affects SQLite process-wide and so is not safe to run as a normal //! #[test] in the library. -#[cfg(feature = "trace")] +#[cfg(all( + feature = "trace", + not(any( + feature = "loadable_extension", + feature = "loadable_extension_embedded" + )) +))] fn main() { use lazy_static::lazy_static; use std::os::raw::c_int; @@ -30,5 +36,9 @@ fn main() { assert_eq!(logs_received[0].1, "First message from rusqlite"); } -#[cfg(not(feature = "trace"))] +#[cfg(any( + not(feature = "trace"), + feature = "loadable_extension", + feature = "loadable_extension_embedded" +))] fn main() {} From 643c0f699f83348e70957244d016133f1e5481b1 Mon Sep 17 00:00:00 2001 From: gwenn Date: Sun, 8 Mar 2020 12:55:13 +0100 Subject: [PATCH 32/61] Introduce `to_sqlite_error` --- src/error.rs | 49 +++++++++++++++++++++++++++++++++++++++++++++++ src/lib.rs | 5 +++++ src/vtab/mod.rs | 51 +++++-------------------------------------------- 3 files changed, 59 insertions(+), 46 deletions(-) diff --git a/src/error.rs b/src/error.rs index 5a64cfe38..856b2ec0d 100644 --- a/src/error.rs +++ b/src/error.rs @@ -359,3 +359,52 @@ macro_rules! check { } }}; } + +#[cfg(any( + feature = "vtab", + feature = "loadable_extension", + feature = "loadable_extension_embedded" +))] +pub unsafe fn to_sqlite_error( + e: &Error, + err_msg: *mut *mut std::os::raw::c_char, +) -> std::os::raw::c_int { + match e { + Error::SqliteFailure(err, s) => { + if let Some(s) = s { + *err_msg = alloc(&s); + } + err.extended_code + } + err => { + *err_msg = alloc(&err.to_string()); + ffi::SQLITE_ERROR + } + } +} + +// Space to hold this string must be obtained +// from an SQLite memory allocation function +#[cfg(any( + feature = "vtab", + feature = "loadable_extension", + feature = "loadable_extension_embedded" +))] +pub(crate) unsafe fn alloc>(s: S) -> *mut std::os::raw::c_char { + use std::convert::TryInto; + let s = s.as_ref(); + if memchr::memchr(0, s).is_some() { + panic!("Null character found") + } + let len = s.len(); + let total_len = len.checked_add(1).unwrap(); + + let dst = ffi::sqlite3_malloc(total_len.try_into().unwrap()) as *mut std::os::raw::c_char; + if dst.is_null() { + panic!("Out of memory") + } + std::ptr::copy_nonoverlapping(s.as_ptr() as *const std::os::raw::c_char, dst, len); + // null terminator + *dst.offset(len.try_into().unwrap()) = 0; + dst +} diff --git a/src/lib.rs b/src/lib.rs index 21c3e8b95..5d95c7246 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -77,6 +77,11 @@ use crate::types::ValueRef; pub use crate::cache::CachedStatement; pub use crate::column::Column; +#[cfg(any( + feature = "loadable_extension", + feature = "loadable_extension_embedded" +))] +pub use crate::error::to_sqlite_error; pub use crate::error::Error; pub use crate::ffi::ErrorCode; #[cfg(feature = "hooks")] diff --git a/src/vtab/mod.rs b/src/vtab/mod.rs index 9eab0d556..9caa32258 100644 --- a/src/vtab/mod.rs +++ b/src/vtab/mod.rs @@ -17,7 +17,7 @@ use std::ptr; use std::slice; use crate::context::set_result; -use crate::error::error_from_sqlite_code; +use crate::error::{alloc, error_from_sqlite_code, to_sqlite_error}; use crate::ffi; pub use crate::ffi::{sqlite3_vtab, sqlite3_vtab_cursor}; use crate::types::{FromSql, FromSqlError, ToSql, ValueRef}; @@ -704,8 +704,7 @@ where ffi::SQLITE_OK } else { let err = error_from_sqlite_code(rc, None); - *err_msg = alloc(&err.to_string()); - rc + to_sqlite_error(&err, err_msg) } } Err(err) => { @@ -713,16 +712,7 @@ where ffi::SQLITE_ERROR } }, - Err(Error::SqliteFailure(err, s)) => { - if let Some(s) = s { - *err_msg = alloc(&s); - } - err.extended_code - } - Err(err) => { - *err_msg = alloc(&err.to_string()); - ffi::SQLITE_ERROR - } + Err(err) => to_sqlite_error(&err, err_msg), } } @@ -756,8 +746,7 @@ where ffi::SQLITE_OK } else { let err = error_from_sqlite_code(rc, None); - *err_msg = alloc(&err.to_string()); - rc + to_sqlite_error(&err, err_msg) } } Err(err) => { @@ -765,16 +754,7 @@ where ffi::SQLITE_ERROR } }, - Err(Error::SqliteFailure(err, s)) => { - if let Some(s) = s { - *err_msg = alloc(&s); - } - err.extended_code - } - Err(err) => { - *err_msg = alloc(&err.to_string()); - ffi::SQLITE_ERROR - } + Err(err) => to_sqlite_error(&err, err_msg), } } @@ -1005,27 +985,6 @@ unsafe fn result_error(ctx: *mut ffi::sqlite3_context, result: Result) -> } } -// Space to hold this string must be obtained -// from an SQLite memory allocation function -unsafe fn alloc>(s: S) -> *mut c_char { - use std::convert::TryInto; - let s = s.as_ref(); - if memchr::memchr(0, s).is_some() { - panic!("Null character found") - } - let len = s.len(); - let total_len = len.checked_add(1).unwrap(); - - let dst = ffi::sqlite3_malloc(total_len.try_into().unwrap()) as *mut c_char; - if dst.is_null() { - panic!("Out of memory") - } - ptr::copy_nonoverlapping(s.as_ptr() as *const c_char, dst, len); - // null terminator - *dst.offset(len.try_into().unwrap()) = 0; - dst -} - #[cfg(feature = "array")] pub mod array; #[cfg(feature = "csvtab")] From a252561f0d60a392140c82a499784f2b3fb85cac Mon Sep 17 00:00:00 2001 From: gwenn Date: Sun, 8 Mar 2020 12:58:55 +0100 Subject: [PATCH 33/61] Add `dummy-extension` module --- Cargo.toml | 2 +- dummy-extension/Cargo.toml | 15 +++++++++++++++ dummy-extension/src/lib.rs | 23 +++++++++++++++++++++++ 3 files changed, 39 insertions(+), 1 deletion(-) create mode 100644 dummy-extension/Cargo.toml create mode 100644 dummy-extension/src/lib.rs diff --git a/Cargo.toml b/Cargo.toml index 5dd88bd9b..e9395bd97 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -20,7 +20,7 @@ maintenance = { status = "actively-developed" } name = "rusqlite" [workspace] -members = ["libsqlite3-sys"] +members = ["libsqlite3-sys", "dummy-extension"] [features] load_extension = [] diff --git a/dummy-extension/Cargo.toml b/dummy-extension/Cargo.toml new file mode 100644 index 000000000..788ee8da7 --- /dev/null +++ b/dummy-extension/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "dummy-extension" +version = "0.0.1" +authors = ["John Gallagher "] +edition = "2018" +repository = "https://github.com/jgallagher/rusqlite" +description = "Dummy extension" +license = "MIT" +keywords = ["sqlite", "extension"] + +[dependencies.rusqlite] +path = ".." +default-features = false +features = ["loadable_extension", "vtab"] +version = "0.21.0" diff --git a/dummy-extension/src/lib.rs b/dummy-extension/src/lib.rs new file mode 100644 index 000000000..3a47a6579 --- /dev/null +++ b/dummy-extension/src/lib.rs @@ -0,0 +1,23 @@ +use std::os::raw::{c_char, c_int}; + +use rusqlite::ffi; +use rusqlite::{to_sqlite_error, Connection}; + +#[allow(clippy::not_unsafe_ptr_arg_deref)] +#[no_mangle] +pub extern "C" fn sqlite3_extension_init( + db: *mut ffi::sqlite3, + pz_err_msg: *mut *mut c_char, + p_api: *mut ffi::sqlite3_api_routines, +) -> c_int { + // SQLITE_EXTENSION_INIT2 equivalent + unsafe { + ffi::sqlite3_api = p_api; + } + let res = unsafe { Connection::from_handle(db) }; + if let Err(err) = res { + return unsafe { to_sqlite_error(&err, pz_err_msg) }; + } + // TODO ... + ffi::SQLITE_OK +} From bceef659c738968c6625a346f678d34b4c3742a6 Mon Sep 17 00:00:00 2001 From: gwenn Date: Sun, 15 Mar 2020 09:21:08 +0100 Subject: [PATCH 34/61] Fix dummy-extension module Register a dummy virtual table Generate a C dynamic library --- .github/workflows/main.yml | 4 +- dummy-extension/Cargo.toml | 3 ++ dummy-extension/src/lib.rs | 88 ++++++++++++++++++++++++++++++++++++-- 3 files changed, 90 insertions(+), 5 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 85c2704e1..7b93850f5 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -32,8 +32,8 @@ jobs: profile: minimal toolchain: stable override: true - - run: cargo build --features bundled - - run: cargo test --features bundled + - run: cargo build --all --all-targets --features bundled + - run: cargo test --all-targets --features bundled - name: Static build if: matrix.platform.os == 'windows-latest' shell: cmd diff --git a/dummy-extension/Cargo.toml b/dummy-extension/Cargo.toml index 788ee8da7..ae23a7a37 100644 --- a/dummy-extension/Cargo.toml +++ b/dummy-extension/Cargo.toml @@ -8,6 +8,9 @@ description = "Dummy extension" license = "MIT" keywords = ["sqlite", "extension"] +[lib] +crate-type = ["cdylib"] + [dependencies.rusqlite] path = ".." default-features = false diff --git a/dummy-extension/src/lib.rs b/dummy-extension/src/lib.rs index 3a47a6579..5645a2fe0 100644 --- a/dummy-extension/src/lib.rs +++ b/dummy-extension/src/lib.rs @@ -1,7 +1,11 @@ use std::os::raw::{c_char, c_int}; use rusqlite::ffi; -use rusqlite::{to_sqlite_error, Connection}; +use rusqlite::vtab::{ + eponymous_only_module, sqlite3_vtab, sqlite3_vtab_cursor, Context, IndexInfo, VTab, + VTabConnection, VTabCursor, Values, +}; +use rusqlite::{to_sqlite_error, Connection, Result}; #[allow(clippy::not_unsafe_ptr_arg_deref)] #[no_mangle] @@ -14,10 +18,88 @@ pub extern "C" fn sqlite3_extension_init( unsafe { ffi::sqlite3_api = p_api; } - let res = unsafe { Connection::from_handle(db) }; + let res = dummy_init(db); if let Err(err) = res { return unsafe { to_sqlite_error(&err, pz_err_msg) }; } - // TODO ... + ffi::SQLITE_OK } + +fn dummy_init(db: *mut ffi::sqlite3) -> Result<()> { + let conn = unsafe { Connection::from_handle(db)? }; + + // Dummy virtual table + let module = eponymous_only_module::(1); + + #[repr(C)] + struct DummyTab { + /// Base class. Must be first + base: sqlite3_vtab, + } + + impl VTab for DummyTab { + type Aux = (); + type Cursor = DummyTabCursor; + + fn connect( + _: &mut VTabConnection, + _aux: Option<&()>, + _args: &[&[u8]], + ) -> Result<(String, DummyTab)> { + let vtab = DummyTab { + base: sqlite3_vtab::default(), + }; + Ok(("CREATE TABLE x(value)".to_owned(), vtab)) + } + + fn best_index(&self, info: &mut IndexInfo) -> Result<()> { + info.set_estimated_cost(1.); + Ok(()) + } + + fn open(&self) -> Result { + Ok(DummyTabCursor::default()) + } + } + + #[derive(Default)] + #[repr(C)] + struct DummyTabCursor { + /// Base class. Must be first + base: sqlite3_vtab_cursor, + /// The rowid + row_id: i64, + } + + impl VTabCursor for DummyTabCursor { + fn filter( + &mut self, + _idx_num: c_int, + _idx_str: Option<&str>, + _args: &Values<'_>, + ) -> Result<()> { + self.row_id = 1; + Ok(()) + } + + fn next(&mut self) -> Result<()> { + self.row_id += 1; + Ok(()) + } + + fn eof(&self) -> bool { + self.row_id > 1 + } + + fn column(&self, ctx: &mut Context, _: c_int) -> Result<()> { + ctx.set_result(&self.row_id) + } + + fn rowid(&self) -> Result { + Ok(self.row_id) + } + } + + conn.create_module::("dummy", &module, None) +} From 03cb901a7a0c47983b41207c1aff88e01c95e7b4 Mon Sep 17 00:00:00 2001 From: gwenn Date: Sun, 15 Mar 2020 09:23:28 +0100 Subject: [PATCH 35/61] Document and export check macro --- src/error.rs | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/error.rs b/src/error.rs index 856b2ec0d..a7725ee3b 100644 --- a/src/error.rs +++ b/src/error.rs @@ -351,6 +351,17 @@ pub fn error_from_handle(db: *mut ffi::sqlite3, code: c_int) -> Error { error_from_sqlite_code(code, message) } +/// Check SQLite method call. +/// ```rust,no_run +/// fn xyz() -> Result<()> { +/// unsafe { +/// // returns an Error if sqlite3_initialize fails +/// check!(ffi::sqlite3_initialize()); +/// } +/// Ok(()) +/// } +/// ``` +#[macro_export] macro_rules! check { ($funcall:expr) => {{ let rc = $funcall; @@ -360,6 +371,7 @@ macro_rules! check { }}; } +/// Transform Rust error to SQLite error (message and code). #[cfg(any( feature = "vtab", feature = "loadable_extension", From ad842a3e3d73e423592373109f772f5745a3c115 Mon Sep 17 00:00:00 2001 From: gwenn Date: Sun, 15 Mar 2020 10:00:22 +0100 Subject: [PATCH 36/61] Try to fix CI build --- .github/workflows/main.yml | 4 ++-- src/error.rs | 5 +++-- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index a50c4f137..7c1d4c9df 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -33,8 +33,8 @@ jobs: toolchain: stable override: true - run: cargo build --features bundled --workspace --all-targets - - run: cargo test --features bundled --workspace --all-targets - - run: cargo test --features bundled --workspace --doc + - run: cargo test --features bundled --workspace --all-targets --exclude dummy-extension + - run: cargo test --features bundled --workspace --doc --exclude dummy-extension - name: Static build if: matrix.platform.os == 'windows-latest' shell: cmd diff --git a/src/error.rs b/src/error.rs index a7725ee3b..13437e40c 100644 --- a/src/error.rs +++ b/src/error.rs @@ -353,15 +353,16 @@ pub fn error_from_handle(db: *mut ffi::sqlite3, code: c_int) -> Error { /// Check SQLite method call. /// ```rust,no_run +/// # use rusqlite::{self, ffi, Result}; +/// /// fn xyz() -> Result<()> { /// unsafe { /// // returns an Error if sqlite3_initialize fails -/// check!(ffi::sqlite3_initialize()); +/// rusqlite::check!(ffi::sqlite3_initialize()); /// } /// Ok(()) /// } /// ``` -#[macro_export] macro_rules! check { ($funcall:expr) => {{ let rc = $funcall; From f1ae27caa48d51de3b547bfaf83b7cfbb1e56daf Mon Sep 17 00:00:00 2001 From: gwenn Date: Sun, 15 Mar 2020 12:09:10 +0100 Subject: [PATCH 37/61] Fix dummy-extension Module reference must be static --- dummy-extension/Cargo.toml | 3 + dummy-extension/src/lib.rs | 134 ++++++++++++++++++------------------- 2 files changed, 70 insertions(+), 67 deletions(-) diff --git a/dummy-extension/Cargo.toml b/dummy-extension/Cargo.toml index ae23a7a37..1691d90cd 100644 --- a/dummy-extension/Cargo.toml +++ b/dummy-extension/Cargo.toml @@ -11,6 +11,9 @@ keywords = ["sqlite", "extension"] [lib] crate-type = ["cdylib"] +[dependencies] +lazy_static = "1.0" + [dependencies.rusqlite] path = ".." default-features = false diff --git a/dummy-extension/src/lib.rs b/dummy-extension/src/lib.rs index 5645a2fe0..b74bbb13f 100644 --- a/dummy-extension/src/lib.rs +++ b/dummy-extension/src/lib.rs @@ -2,7 +2,7 @@ use std::os::raw::{c_char, c_int}; use rusqlite::ffi; use rusqlite::vtab::{ - eponymous_only_module, sqlite3_vtab, sqlite3_vtab_cursor, Context, IndexInfo, VTab, + eponymous_only_module, sqlite3_vtab, sqlite3_vtab_cursor, Context, IndexInfo, Module, VTab, VTabConnection, VTabCursor, Values, }; use rusqlite::{to_sqlite_error, Connection, Result}; @@ -26,80 +26,80 @@ pub extern "C" fn sqlite3_extension_init( ffi::SQLITE_OK } -fn dummy_init(db: *mut ffi::sqlite3) -> Result<()> { - let conn = unsafe { Connection::from_handle(db)? }; +lazy_static::lazy_static! { + static ref DUMMY_MODULE: Module = eponymous_only_module::(1); +} +#[repr(C)] +struct DummyTab { + /// Base class. Must be first + base: sqlite3_vtab, +} + +impl VTab for DummyTab { + type Aux = (); + type Cursor = DummyTabCursor; + + fn connect( + _: &mut VTabConnection, + _aux: Option<&()>, + _args: &[&[u8]], + ) -> Result<(String, DummyTab)> { + let vtab = DummyTab { + base: sqlite3_vtab::default(), + }; + Ok(("CREATE TABLE x(value)".to_owned(), vtab)) + } + + fn best_index(&self, info: &mut IndexInfo) -> Result<()> { + info.set_estimated_cost(1.); + Ok(()) + } + + fn open(&self) -> Result { + Ok(DummyTabCursor::default()) + } +} - // Dummy virtual table - let module = eponymous_only_module::(1); +#[derive(Default)] +#[repr(C)] +struct DummyTabCursor { + /// Base class. Must be first + base: sqlite3_vtab_cursor, + /// The rowid + row_id: i64, +} + +impl VTabCursor for DummyTabCursor { + fn filter( + &mut self, + _idx_num: c_int, + _idx_str: Option<&str>, + _args: &Values<'_>, + ) -> Result<()> { + self.row_id = 1; + Ok(()) + } - #[repr(C)] - struct DummyTab { - /// Base class. Must be first - base: sqlite3_vtab, + fn next(&mut self) -> Result<()> { + self.row_id += 1; + Ok(()) } - impl VTab for DummyTab { - type Aux = (); - type Cursor = DummyTabCursor; - - fn connect( - _: &mut VTabConnection, - _aux: Option<&()>, - _args: &[&[u8]], - ) -> Result<(String, DummyTab)> { - let vtab = DummyTab { - base: sqlite3_vtab::default(), - }; - Ok(("CREATE TABLE x(value)".to_owned(), vtab)) - } - - fn best_index(&self, info: &mut IndexInfo) -> Result<()> { - info.set_estimated_cost(1.); - Ok(()) - } - - fn open(&self) -> Result { - Ok(DummyTabCursor::default()) - } + fn eof(&self) -> bool { + self.row_id > 1 } - #[derive(Default)] - #[repr(C)] - struct DummyTabCursor { - /// Base class. Must be first - base: sqlite3_vtab_cursor, - /// The rowid - row_id: i64, + fn column(&self, ctx: &mut Context, _: c_int) -> Result<()> { + ctx.set_result(&self.row_id) } - impl VTabCursor for DummyTabCursor { - fn filter( - &mut self, - _idx_num: c_int, - _idx_str: Option<&str>, - _args: &Values<'_>, - ) -> Result<()> { - self.row_id = 1; - Ok(()) - } - - fn next(&mut self) -> Result<()> { - self.row_id += 1; - Ok(()) - } - - fn eof(&self) -> bool { - self.row_id > 1 - } - - fn column(&self, ctx: &mut Context, _: c_int) -> Result<()> { - ctx.set_result(&self.row_id) - } - - fn rowid(&self) -> Result { - Ok(self.row_id) - } + fn rowid(&self) -> Result { + Ok(self.row_id) } +} + +fn dummy_init(db: *mut ffi::sqlite3) -> Result<()> { + let conn = unsafe { Connection::from_handle(db)? }; - conn.create_module::("dummy", &module, None) + conn.create_module::("dummy", &DUMMY_MODULE, None) } From bbbc76a94a78844f8bb87b627dad2d739f58522f Mon Sep 17 00:00:00 2001 From: gwenn Date: Sat, 13 Jun 2020 16:54:01 +0200 Subject: [PATCH 38/61] Fix build error unresolved import `crate::util::alloc` --- src/error.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/error.rs b/src/error.rs index dd3b9b42f..55b307c80 100644 --- a/src/error.rs +++ b/src/error.rs @@ -1,6 +1,5 @@ use crate::types::FromSqlError; use crate::types::Type; -use crate::util::alloc; use crate::{errmsg_to_string, ffi}; use std::error; use std::fmt; @@ -357,6 +356,7 @@ pub unsafe fn to_sqlite_error( e: &Error, err_msg: *mut *mut std::os::raw::c_char, ) -> std::os::raw::c_int { + use crate::util::alloc; match e { Error::SqliteFailure(err, s) => { if let Some(s) = s { From 61ee112ee413462a602dc842152ca991e7f1697d Mon Sep 17 00:00:00 2001 From: gwenn Date: Sat, 13 Jun 2020 17:23:52 +0200 Subject: [PATCH 39/61] Fix bindgen ext files. --- .../bindgen-bindings/bindgen_3.6.8-ext.rs | 10 ---------- .../bindgen-bindings/bindgen_3.7.16-ext.rs | 20 ------------------- .../sqlite3/bindgen_bundled_version-ext.rs | 10 ---------- 3 files changed, 40 deletions(-) diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs index 2896fcac5..e0014c651 100644 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs @@ -4119,16 +4119,6 @@ fn bindgen_test_layout_sqlite3_api_routines() { stringify!(value_type) ) ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, - 912usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vmprintf) - ) - ); assert_eq!( unsafe { &(*(::std::ptr::null::())).overload_function as *const _ as usize diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs index b37cd434d..8642a37e4 100644 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs @@ -4919,16 +4919,6 @@ fn bindgen_test_layout_sqlite3_api_routines() { stringify!(value_type) ) ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, - 912usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vmprintf) - ) - ); assert_eq!( unsafe { &(*(::std::ptr::null::())).overload_function as *const _ as usize @@ -5776,16 +5766,6 @@ fn bindgen_test_layout_sqlite3_api_routines() { stringify!(uri_parameter) ) ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vsnprintf as *const _ as usize }, - 1520usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vsnprintf) - ) - ); assert_eq!( unsafe { &(*(::std::ptr::null::())).wal_checkpoint_v2 as *const _ as usize diff --git a/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs b/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs index 0aba33ad9..72e404ebc 100644 --- a/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs +++ b/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs @@ -6286,16 +6286,6 @@ fn bindgen_test_layout_sqlite3_api_routines() { stringify!(value_type) ) ); - assert_eq!( - unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, - 912usize, - concat!( - "Offset of field: ", - stringify!(sqlite3_api_routines), - "::", - stringify!(vmprintf) - ) - ); assert_eq!( unsafe { &(*(::std::ptr::null::())).overload_function as *const _ as usize From a20039ba33fb71c3f42f3d9c5fa651a619879989 Mon Sep 17 00:00:00 2001 From: gwenn Date: Sat, 13 Jun 2020 17:24:29 +0200 Subject: [PATCH 40/61] Export check macro --- src/error.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/error.rs b/src/error.rs index 55b307c80..80eb465ac 100644 --- a/src/error.rs +++ b/src/error.rs @@ -337,6 +337,7 @@ pub unsafe fn error_from_handle(db: *mut ffi::sqlite3, code: c_int) -> Error { /// Ok(()) /// } /// ``` +#[macro_export] macro_rules! check { ($funcall:expr) => {{ let rc = $funcall; From 9b93d388bb4eb69fdfe3e0dd04ca00dc0927cdb5 Mon Sep 17 00:00:00 2001 From: gwenn Date: Sat, 13 Jun 2020 17:53:56 +0200 Subject: [PATCH 41/61] Fix to_sqlite_error doc --- src/error.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/error.rs b/src/error.rs index 80eb465ac..ef6d14382 100644 --- a/src/error.rs +++ b/src/error.rs @@ -348,6 +348,8 @@ macro_rules! check { } /// Transform Rust error to SQLite error (message and code). +/// # Safety +/// This function is unsafe because it uses raw pointer #[cfg(any( feature = "vtab", feature = "loadable_extension", From 3770778ca625f31d4d4367848a8cf3c60d1df4cc Mon Sep 17 00:00:00 2001 From: gwenn Date: Sat, 13 Jun 2020 17:54:26 +0200 Subject: [PATCH 42/61] Fix dummy extension --- dummy-extension/Cargo.toml | 1 - dummy-extension/src/lib.rs | 19 +++++++++---------- 2 files changed, 9 insertions(+), 11 deletions(-) diff --git a/dummy-extension/Cargo.toml b/dummy-extension/Cargo.toml index 9042f7336..ffdf7dfcf 100644 --- a/dummy-extension/Cargo.toml +++ b/dummy-extension/Cargo.toml @@ -12,7 +12,6 @@ keywords = ["sqlite", "extension"] crate-type = ["cdylib"] [dependencies] -lazy_static = "1.0" [dependencies.rusqlite] path = ".." diff --git a/dummy-extension/src/lib.rs b/dummy-extension/src/lib.rs index b74bbb13f..977441d8e 100644 --- a/dummy-extension/src/lib.rs +++ b/dummy-extension/src/lib.rs @@ -1,8 +1,9 @@ +use std::marker::PhantomData; use std::os::raw::{c_char, c_int}; use rusqlite::ffi; use rusqlite::vtab::{ - eponymous_only_module, sqlite3_vtab, sqlite3_vtab_cursor, Context, IndexInfo, Module, VTab, + eponymous_only_module, sqlite3_vtab, sqlite3_vtab_cursor, Context, IndexInfo, VTab, VTabConnection, VTabCursor, Values, }; use rusqlite::{to_sqlite_error, Connection, Result}; @@ -26,18 +27,15 @@ pub extern "C" fn sqlite3_extension_init( ffi::SQLITE_OK } -lazy_static::lazy_static! { - static ref DUMMY_MODULE: Module = eponymous_only_module::(1); -} #[repr(C)] struct DummyTab { /// Base class. Must be first base: sqlite3_vtab, } -impl VTab for DummyTab { +unsafe impl<'vtab> VTab<'vtab> for DummyTab { type Aux = (); - type Cursor = DummyTabCursor; + type Cursor = DummyTabCursor<'vtab>; fn connect( _: &mut VTabConnection, @@ -55,21 +53,22 @@ impl VTab for DummyTab { Ok(()) } - fn open(&self) -> Result { + fn open(&'vtab self) -> Result> { Ok(DummyTabCursor::default()) } } #[derive(Default)] #[repr(C)] -struct DummyTabCursor { +struct DummyTabCursor<'vtab> { /// Base class. Must be first base: sqlite3_vtab_cursor, /// The rowid row_id: i64, + phantom: PhantomData<&'vtab DummyTab>, } -impl VTabCursor for DummyTabCursor { +unsafe impl VTabCursor for DummyTabCursor<'_> { fn filter( &mut self, _idx_num: c_int, @@ -101,5 +100,5 @@ impl VTabCursor for DummyTabCursor { fn dummy_init(db: *mut ffi::sqlite3) -> Result<()> { let conn = unsafe { Connection::from_handle(db)? }; - conn.create_module::("dummy", &DUMMY_MODULE, None) + conn.create_module::("dummy", eponymous_only_module::(), None) } From 944ad5ee92489f671bbbaf4e89a6d2e72eaf3ae0 Mon Sep 17 00:00:00 2001 From: gwenn Date: Sat, 13 Jun 2020 18:18:48 +0200 Subject: [PATCH 43/61] Fix sqlite3_api_routines size --- libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs | 2 +- libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs | 2 +- libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs index e0014c651..97bb8b349 100644 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs @@ -2818,7 +2818,7 @@ pub struct sqlite3_api_routines { fn bindgen_test_layout_sqlite3_api_routines() { assert_eq!( ::std::mem::size_of::(), - 1240usize, + 1232usize, concat!("Size of: ", stringify!(sqlite3_api_routines)) ); assert_eq!( diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs index 8642a37e4..c482c77b9 100644 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs @@ -3618,7 +3618,7 @@ pub struct sqlite3_api_routines { fn bindgen_test_layout_sqlite3_api_routines() { assert_eq!( ::std::mem::size_of::(), - 1536usize, + 1520usize, concat!("Size of: ", stringify!(sqlite3_api_routines)) ); assert_eq!( diff --git a/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs b/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs index 72e404ebc..7a8372957 100644 --- a/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs +++ b/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs @@ -4985,7 +4985,7 @@ pub struct sqlite3_api_routines { fn bindgen_test_layout_sqlite3_api_routines() { assert_eq!( ::std::mem::size_of::(), - 2016usize, + 1992usize, concat!("Size of: ", stringify!(sqlite3_api_routines)) ); assert_eq!( From c409018608e22cf54975143a8d39f77577b78551 Mon Sep 17 00:00:00 2001 From: phiresky Date: Wed, 16 Dec 2020 14:54:58 +0100 Subject: [PATCH 44/61] fix build for loadable_extension --- dummy-extension/Cargo.toml | 2 +- dummy-extension/src/lib.rs | 2 +- libsqlite3-sys/build.rs | 1 + libsqlite3-sys/upgrade.sh | 7 ++++--- src/error.rs | 5 +++-- 5 files changed, 10 insertions(+), 7 deletions(-) diff --git a/dummy-extension/Cargo.toml b/dummy-extension/Cargo.toml index ffdf7dfcf..657ec2229 100644 --- a/dummy-extension/Cargo.toml +++ b/dummy-extension/Cargo.toml @@ -17,4 +17,4 @@ crate-type = ["cdylib"] path = ".." default-features = false features = ["loadable_extension", "vtab"] -version = "0.23.1" +version = "0.24.2" diff --git a/dummy-extension/src/lib.rs b/dummy-extension/src/lib.rs index 977441d8e..50eff167b 100644 --- a/dummy-extension/src/lib.rs +++ b/dummy-extension/src/lib.rs @@ -99,6 +99,6 @@ unsafe impl VTabCursor for DummyTabCursor<'_> { fn dummy_init(db: *mut ffi::sqlite3) -> Result<()> { let conn = unsafe { Connection::from_handle(db)? }; - + println!("initied dummy module"); conn.create_module::("dummy", eponymous_only_module::(), None) } diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index a54293cae..85a49c1a6 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -523,6 +523,7 @@ mod bindings { // Note that when generating the bundled file, we're essentially always // cross compiling. + #[cfg(not(feature = "loadable_extension"))] if generating_bundled_bindings() || is_cross_compiling { // Get rid of va_list, as it's not bindings = bindings diff --git a/libsqlite3-sys/upgrade.sh b/libsqlite3-sys/upgrade.sh index 00965b1b8..9d41cba56 100755 --- a/libsqlite3-sys/upgrade.sh +++ b/libsqlite3-sys/upgrade.sh @@ -1,6 +1,7 @@ #!/bin/bash SCRIPT_DIR=$(cd "$(dirname "$_")" && pwd) +TARGET_DIR="$SCRIPT_DIR/../target" # ensure target dir is deterministic echo "$SCRIPT_DIR" cd "$SCRIPT_DIR" || { echo "fatal error"; exit 1; } export SQLITE3_LIB_DIR=$SCRIPT_DIR/sqlite3 @@ -23,9 +24,9 @@ function generate_bindgen_binding() { rm -f "$target_file" # Just to make sure there is only one bindgen.rs file in target dir - find "$SCRIPT_DIR/../target" -type f -name bindgen.rs -exec rm {} \; - env LIBSQLITE3_SYS_BUNDLING=1 cargo build --features "$features" --no-default-features - find "$SCRIPT_DIR/../target" -type f -name bindgen.rs -exec cp {} "$target_file" \; + find "$TARGET_DIR" -type f -name bindgen.rs -exec rm {} \; + env LIBSQLITE3_SYS_BUNDLING=1 cargo build --target-dir "$TARGET_DIR" --features "$features" --no-default-features + find "$TARGET_DIR" -type f -name bindgen.rs -exec cp {} "$target_file" \; # rerun rustfmt after (possibly) adding wrappers rustfmt $target_file } diff --git a/src/error.rs b/src/error.rs index 9a487117e..5312f1cef 100644 --- a/src/error.rs +++ b/src/error.rs @@ -345,11 +345,12 @@ pub unsafe fn error_from_handle(db: *mut ffi::sqlite3, code: c_int) -> Error { error_from_sqlite_code(code, message) } + /// Check SQLite method call. -/// ```rust,no_run +/// ```rust,ignore /// # use rusqlite::{self, ffi, Result}; -/// /// fn xyz() -> Result<()> { +/// /// unsafe { /// // returns an Error if sqlite3_initialize fails /// rusqlite::check!(ffi::sqlite3_initialize()); From 44cf29526ad3397a790db11ca75ce48b45106aa4 Mon Sep 17 00:00:00 2001 From: phiresky Date: Wed, 16 Dec 2020 14:55:17 +0100 Subject: [PATCH 45/61] update bundled bindgen for loadable_extension --- .../sqlite3/bindgen_bundled_version-ext.rs | 222 +++++++++++++++++- 1 file changed, 210 insertions(+), 12 deletions(-) diff --git a/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs b/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs index 7a8372957..df7bfaf36 100644 --- a/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs +++ b/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs @@ -1,9 +1,10 @@ -/* automatically generated by rust-bindgen */ +/* automatically generated by rust-bindgen 0.56.0 */ -pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.32.2\0"; -pub const SQLITE_VERSION_NUMBER: i32 = 3032002; +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.34.0\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3034000; pub const SQLITE_SOURCE_ID: &'static [u8; 85usize] = - b"2020-06-04 12:58:43 ec02243ea6ce33b090870ae55ab8aa2534b54d216d45c4aa2fdbb00e86861e8c\0"; + b"2020-12-01 16:14:00 a26b6597e3ae272231b96f9982c3bcc17ddec2f2b6eb4df06a224b91089fed5b\0"; pub const SQLITE_OK: i32 = 0; pub const SQLITE_ERROR: i32 = 1; pub const SQLITE_INTERNAL: i32 = 2; @@ -70,6 +71,7 @@ pub const SQLITE_IOERR_BEGIN_ATOMIC: i32 = 7434; pub const SQLITE_IOERR_COMMIT_ATOMIC: i32 = 7690; pub const SQLITE_IOERR_ROLLBACK_ATOMIC: i32 = 7946; pub const SQLITE_IOERR_DATA: i32 = 8202; +pub const SQLITE_IOERR_CORRUPTFS: i32 = 8458; pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; pub const SQLITE_LOCKED_VTAB: i32 = 518; pub const SQLITE_BUSY_RECOVERY: i32 = 261; @@ -122,13 +124,14 @@ pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; -pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; +pub const SQLITE_OPEN_SUPER_JOURNAL: i32 = 16384; pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; pub const SQLITE_OPEN_WAL: i32 = 524288; pub const SQLITE_OPEN_NOFOLLOW: i32 = 16777216; +pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; pub const SQLITE_IOCAP_ATOMIC: i32 = 1; pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; @@ -321,6 +324,9 @@ pub const SQLITE_SUBTYPE: i32 = 1048576; pub const SQLITE_INNOCUOUS: i32 = 2097152; pub const SQLITE_WIN32_DATA_DIRECTORY_TYPE: i32 = 1; pub const SQLITE_WIN32_TEMP_DIRECTORY_TYPE: i32 = 2; +pub const SQLITE_TXN_NONE: i32 = 0; +pub const SQLITE_TXN_READ: i32 = 1; +pub const SQLITE_TXN_WRITE: i32 = 2; pub const SQLITE_INDEX_SCAN_UNIQUE: i32 = 1; pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; @@ -339,7 +345,7 @@ pub const SQLITE_INDEX_CONSTRAINT_IS: i32 = 72; pub const SQLITE_INDEX_CONSTRAINT_FUNCTION: i32 = 150; pub const SQLITE_MUTEX_FAST: i32 = 0; pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; -pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; +pub const SQLITE_MUTEX_STATIC_MAIN: i32 = 2; pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; @@ -353,6 +359,7 @@ pub const SQLITE_MUTEX_STATIC_APP3: i32 = 10; pub const SQLITE_MUTEX_STATIC_VFS1: i32 = 11; pub const SQLITE_MUTEX_STATIC_VFS2: i32 = 12; pub const SQLITE_MUTEX_STATIC_VFS3: i32 = 13; +pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; pub const SQLITE_TESTCTRL_FIRST: i32 = 5; pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; @@ -381,7 +388,8 @@ pub const SQLITE_TESTCTRL_PARSER_COVERAGE: i32 = 26; pub const SQLITE_TESTCTRL_RESULT_INTREAL: i32 = 27; pub const SQLITE_TESTCTRL_PRNG_SEED: i32 = 28; pub const SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS: i32 = 29; -pub const SQLITE_TESTCTRL_LAST: i32 = 29; +pub const SQLITE_TESTCTRL_SEEK_COUNT: i32 = 30; +pub const SQLITE_TESTCTRL_LAST: i32 = 30; pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; @@ -441,6 +449,8 @@ pub const FTS5_TOKENIZE_PREFIX: i32 = 2; pub const FTS5_TOKENIZE_DOCUMENT: i32 = 4; pub const FTS5_TOKENIZE_AUX: i32 = 8; pub const FTS5_TOKEN_COLOCATED: i32 = 1; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; extern "C" { pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; } @@ -4278,6 +4288,12 @@ pub struct sqlite3_api_routines { pub value_type: ::std::option::Option< unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, >, + pub vmprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, pub overload_function: ::std::option::Option< unsafe extern "C" fn( arg1: *mut sqlite3, @@ -4660,6 +4676,14 @@ pub struct sqlite3_api_routines { arg2: *const ::std::os::raw::c_char, ) -> *const ::std::os::raw::c_char, >, + pub xvsnprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, pub wal_checkpoint_v2: ::std::option::Option< unsafe extern "C" fn( arg1: *mut sqlite3, @@ -4881,6 +4905,13 @@ pub struct sqlite3_api_routines { pub str_appendf: ::std::option::Option< unsafe extern "C" fn(arg1: *mut sqlite3_str, zFormat: *const ::std::os::raw::c_char, ...), >, + pub str_vappendf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_str, + zFormat: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ), + >, pub str_append: ::std::option::Option< unsafe extern "C" fn( arg1: *mut sqlite3_str, @@ -4980,12 +5011,18 @@ pub struct sqlite3_api_routines { pub database_file_object: ::std::option::Option< unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_file, >, + pub txn_state: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, } #[test] fn bindgen_test_layout_sqlite3_api_routines() { assert_eq!( ::std::mem::size_of::(), - 1992usize, + 2024usize, concat!("Size of: ", stringify!(sqlite3_api_routines)) ); assert_eq!( @@ -6286,6 +6323,16 @@ fn bindgen_test_layout_sqlite3_api_routines() { stringify!(value_type) ) ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, + 912usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vmprintf) + ) + ); assert_eq!( unsafe { &(*(::std::ptr::null::())).overload_function as *const _ as usize @@ -7133,6 +7180,16 @@ fn bindgen_test_layout_sqlite3_api_routines() { stringify!(uri_parameter) ) ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xvsnprintf as *const _ as usize }, + 1520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xvsnprintf) + ) + ); assert_eq!( unsafe { &(*(::std::ptr::null::())).wal_checkpoint_v2 as *const _ as usize @@ -7592,6 +7649,18 @@ fn bindgen_test_layout_sqlite3_api_routines() { stringify!(str_appendf) ) ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).str_vappendf as *const _ as usize + }, + 1848usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(str_vappendf) + ) + ); assert_eq!( unsafe { &(*(::std::ptr::null::())).str_append as *const _ as usize }, 1856usize, @@ -7824,6 +7893,16 @@ fn bindgen_test_layout_sqlite3_api_routines() { stringify!(database_file_object) ) ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).txn_state as *const _ as usize }, + 2016usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(txn_state) + ) + ); } pub type sqlite3_loadext_entry = ::std::option::Option< unsafe extern "C" fn( @@ -7832,14 +7911,74 @@ pub type sqlite3_loadext_entry = ::std::option::Option< pThunk: *const sqlite3_api_routines, ) -> ::std::os::raw::c_int, >; +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} -// sqlite3_api is defined in lib.rs as either a static or an extern when -// compiled as a loadable_extension +// sqlite3_api is defined in lib.rs as either a static or an extern when compiled as a loadable_extension #[cfg(feature = "loadable_extension")] use crate::sqlite3_api; -// sqlite3 API wrappers to support loadable extensions (Note: these were -// generated from build.rs - not by rust-bindgen) +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) pub unsafe fn sqlite3_aggregate_context( arg1: *mut sqlite3_context, @@ -9467,6 +9606,20 @@ pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_ )))(arg1) } +pub unsafe fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vmprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vmprintf", + " function" + )))(arg1, arg2) +} + pub unsafe fn sqlite3_overload_function( arg1: *mut sqlite3, zFuncName: *const ::std::os::raw::c_char, @@ -10486,6 +10639,22 @@ pub unsafe fn sqlite3_uri_parameter( )))(arg1, arg2) } +pub unsafe fn sqlite3_xvsnprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xvsnprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xvsnprintf", + " function" + )))(arg1, arg2, arg3, arg4) +} + pub unsafe fn sqlite3_wal_checkpoint_v2( arg1: *mut sqlite3, arg2: *const ::std::os::raw::c_char, @@ -11041,6 +11210,21 @@ pub unsafe fn sqlite3_str_appendf( )))(arg1, zFormat, vararg1) } +pub unsafe fn sqlite3_str_vappendf( + arg1: *mut sqlite3_str, + zFormat: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).str_vappendf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "str_vappendf", + " function" + )))(arg1, zFormat, arg2) +} + pub unsafe fn sqlite3_str_append( arg1: *mut sqlite3_str, zIn: *const ::std::os::raw::c_char, @@ -11313,3 +11497,17 @@ pub unsafe fn sqlite3_database_file_object( " function" )))(arg1) } + +pub unsafe fn sqlite3_txn_state( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).txn_state.expect(stringify!( + "sqlite3_api contains null pointer for ", + "txn_state", + " function" + )))(arg1, arg2) +} From 98bb78f9303d9238167cb8590669db0715a2e8ab Mon Sep 17 00:00:00 2001 From: phiresky Date: Wed, 16 Dec 2020 15:33:25 +0100 Subject: [PATCH 46/61] add test function to dummy module as well --- dummy-extension/Cargo.toml | 2 +- dummy-extension/src/lib.rs | 18 ++++++++++++++++-- 2 files changed, 17 insertions(+), 3 deletions(-) diff --git a/dummy-extension/Cargo.toml b/dummy-extension/Cargo.toml index 657ec2229..c8096a544 100644 --- a/dummy-extension/Cargo.toml +++ b/dummy-extension/Cargo.toml @@ -16,5 +16,5 @@ crate-type = ["cdylib"] [dependencies.rusqlite] path = ".." default-features = false -features = ["loadable_extension", "vtab"] +features = ["loadable_extension", "vtab", "functions", "bundled"] version = "0.24.2" diff --git a/dummy-extension/src/lib.rs b/dummy-extension/src/lib.rs index 50eff167b..ac66824f8 100644 --- a/dummy-extension/src/lib.rs +++ b/dummy-extension/src/lib.rs @@ -1,11 +1,15 @@ use std::marker::PhantomData; use std::os::raw::{c_char, c_int}; -use rusqlite::ffi; use rusqlite::vtab::{ eponymous_only_module, sqlite3_vtab, sqlite3_vtab_cursor, Context, IndexInfo, VTab, VTabConnection, VTabCursor, Values, }; +use rusqlite::{ + ffi, + functions::FunctionFlags, + types::{ToSqlOutput, Value}, +}; use rusqlite::{to_sqlite_error, Connection, Result}; #[allow(clippy::not_unsafe_ptr_arg_deref)] @@ -99,6 +103,16 @@ unsafe impl VTabCursor for DummyTabCursor<'_> { fn dummy_init(db: *mut ffi::sqlite3) -> Result<()> { let conn = unsafe { Connection::from_handle(db)? }; - println!("initied dummy module"); + println!("initied dummy module {:?}", db); + conn.create_scalar_function( + "dummy_test_function", + 0, + FunctionFlags::SQLITE_DETERMINISTIC, + |ctx| { + Ok(ToSqlOutput::Owned(Value::Text( + "Loaded correctly!".to_string(), + ))) + }, + )?; conn.create_module::("dummy", eponymous_only_module::(), None) } From 763364f65eed8752f0adb1e1e17273ea03636070 Mon Sep 17 00:00:00 2001 From: phiresky Date: Fri, 18 Dec 2020 13:56:45 +0100 Subject: [PATCH 47/61] format --- src/error.rs | 1 - src/util/sqlite_string.rs | 7 ++++++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/src/error.rs b/src/error.rs index 5312f1cef..148402bc8 100644 --- a/src/error.rs +++ b/src/error.rs @@ -345,7 +345,6 @@ pub unsafe fn error_from_handle(db: *mut ffi::sqlite3, code: c_int) -> Error { error_from_sqlite_code(code, message) } - /// Check SQLite method call. /// ```rust,ignore /// # use rusqlite::{self, ffi, Result}; diff --git a/src/util/sqlite_string.rs b/src/util/sqlite_string.rs index 309094147..e416be16a 100644 --- a/src/util/sqlite_string.rs +++ b/src/util/sqlite_string.rs @@ -2,7 +2,12 @@ // used in each feature. Avoid having to track this for each function. We will // still warn for anything that's not used by either, though. #![cfg_attr( - not(all(feature = "vtab", feature = "loadable_extension", feature = "loadable_extension_embedded", feature = "modern-sqlite")), + not(all( + feature = "vtab", + feature = "loadable_extension", + feature = "loadable_extension_embedded", + feature = "modern-sqlite" + )), allow(dead_code) )] use crate::ffi; From 28f7c428fa35aa4e3fb263ed1f6e2bc95bed73ef Mon Sep 17 00:00:00 2001 From: "Joshua C. Randall" Date: Sun, 7 Mar 2021 16:13:40 +0000 Subject: [PATCH 48/61] Fix up loadable extensions work --- .github/workflows/main.yml | 10 + .travis.yml | 49 - CONTRIBUTORS.md | 10 + Cargo.toml | 23 +- README.md | 2 + dummy-extension/.gitignore | 3 + dummy-extension/Cargo.toml | 3 + dummy-extension/integration-test.sh | 15 + dummy-extension/src/lib.rs | 4 +- libsqlite3-sys/Cargo.toml | 9 +- libsqlite3-sys/bindgen-bindings/README.md | 2 + .../bindgen-bindings/bindgen_3.6.23-ext.rs | 6839 ++++++++++++++ .../bindgen-bindings/bindgen_3.6.23.rs | 3100 +++++++ .../bindgen-bindings/bindgen_3.6.8-ext.rs | 121 +- .../bindgen-bindings/bindgen_3.6.8.rs | 3549 +++++--- .../bindgen-bindings/bindgen_3.7.16-ext.rs | 226 +- .../bindgen-bindings/bindgen_3.7.16.rs | 4431 +++++++--- .../bindgen-bindings/bindgen_3.7.7-ext.rs | 7857 +++++++++++++++++ .../bindgen-bindings/bindgen_3.7.7.rs | 3506 ++++++++ libsqlite3-sys/build.rs | 355 +- .../sqlite3/bindgen_bundled_version-ext.rs | 193 +- .../sqlite3/bindgen_bundled_version.rs | 2 +- libsqlite3-sys/src/lib.rs | 1 - libsqlite3-sys/upgrade.sh | 10 +- src/cache.rs | 4 +- src/config.rs | 16 + src/error.rs | 23 +- src/inner_connection.rs | 45 +- src/lib.rs | 26 +- src/params.rs | 19 +- src/pragma.rs | 10 +- src/raw_statement.rs | 9 +- src/session.rs | 10 +- src/statement.rs | 60 +- src/trace.rs | 25 +- src/types/chrono.rs | 73 +- src/types/time.rs | 12 +- src/types/url.rs | 2 +- src/util/mod.rs | 15 +- src/util/sqlite_string.rs | 30 +- src/vtab/array.rs | 4 +- src/vtab/mod.rs | 45 +- tests/config_log.rs | 14 +- tests/deny_single_threaded_sqlite_config.rs | 5 +- tests/vtab.rs | 3 +- 45 files changed, 27554 insertions(+), 3216 deletions(-) delete mode 100644 .travis.yml create mode 100644 CONTRIBUTORS.md create mode 100644 dummy-extension/.gitignore create mode 100755 dummy-extension/integration-test.sh create mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.6.23-ext.rs create mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.6.23.rs create mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.7.7-ext.rs create mode 100644 libsqlite3-sys/bindgen-bindings/bindgen_3.7.7.rs diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 38c28c949..70f0f30bc 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -77,6 +77,15 @@ jobs: - run: cargo build --features sqlcipher --workspace --all-targets --verbose - run: cargo test --features sqlcipher --workspace --all-targets --verbose + dummy-extension: + name: Test loadable extensions with dummy-extension + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: hecrj/setup-rust-action@v1 + - run: (cd dummy-extension && cargo build --all-targets --verbose) + - run: ./dummy-extension/integration-test.sh + sanitizer: name: Address Sanitizer runs-on: ubuntu-latest @@ -111,6 +120,7 @@ jobs: - run: cargo clippy --all-targets --workspace --features bundled -- -D warnings # Clippy with all non-conflicting features - run: cargo clippy --all-targets --workspace --features 'bundled-full session buildtime_bindgen time' -- -D warnings + - run: (cd dummy-extension && cargo clippy --all-targets -- -D warnings) # Ensure patch is formatted. fmt: diff --git a/.travis.yml b/.travis.yml deleted file mode 100644 index 7305f14d4..000000000 --- a/.travis.yml +++ /dev/null @@ -1,49 +0,0 @@ -sudo: false - -language: rust - -rust: - - stable - - beta - - nightly - -matrix: - fast_finish: true - allow_failures: - - rust: nightly - -addons: - apt: - packages: # recommanded versions for rust-bindgen - - llvm-3.9-dev - - libclang-3.9-dev - - libsqlcipher-dev - -env: # specify the clang path for rust-bindgen - - LIBCLANG_PATH=/usr/lib/llvm-3.9/lib - -script: - - cargo build - - cargo build --features bundled - - cargo build --features sqlcipher - - cargo build --features "bundled sqlcipher" - - cargo build --features "loadable_extension backup blob collation functions limits hooks unlock_notify vtab window bundled" - - cargo test - - cargo test --features "backup blob extra_check" - - cargo test --features "collation functions" - - cargo test --features "hooks limits" - - cargo test --features load_extension - - cargo test --features trace - - cargo test --features chrono - - cargo test --features serde_json - - cargo test --features url - - cargo test --features bundled - - cargo test --features sqlcipher - - cargo test --features i128_blob - - cargo test --features uuid - - cargo test --features "bundled unlock_notify window" - - cargo test --features "array bundled csvtab series vtab" - - cargo test --features "backup blob chrono collation csvtab functions hooks limits load_extension serde_json trace url uuid vtab" - - cargo test --features "backup blob chrono collation csvtab functions hooks limits load_extension serde_json trace url uuid vtab buildtime_bindgen" - - cargo test --features "backup blob chrono collation csvtab functions hooks limits load_extension serde_json trace url uuid vtab bundled" - - cargo test --features "backup blob chrono collation csvtab functions hooks limits load_extension session serde_json trace url uuid vtab bundled buildtime_bindgen" diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md new file mode 100644 index 000000000..221e63a1c --- /dev/null +++ b/CONTRIBUTORS.md @@ -0,0 +1,10 @@ +Contributors +============ + +"The rusqlite developers" referred to in the copyright notice in the LICENSE +file is intended to include all individual developers who have contributed +code to the rusqlite project. + +In addition, it includes the following organisations who retain copyright in +portions of the code (this list is not intended to be comprehensive): + - Genomics plc diff --git a/Cargo.toml b/Cargo.toml index a98f20747..1ea7bc419 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -12,7 +12,6 @@ license = "MIT" categories = ["database"] [badges] -travis-ci = { repository = "rusqlite/rusqlite" } appveyor = { repository = "rusqlite/rusqlite" } codecov = { repository = "rusqlite/rusqlite" } maintenance = { status = "actively-developed" } @@ -21,38 +20,38 @@ maintenance = { status = "actively-developed" } name = "rusqlite" [workspace] -members = ["libsqlite3-sys", "dummy-extension"] +members = ["libsqlite3-sys"] [features] load_extension = [] # hot-backup interface: 3.6.11 (2009-02-18) -backup = ["libsqlite3-sys/min_sqlite_version_3_7_16"] +backup = ["libsqlite3-sys/min_sqlite_version_3_6_23"] # sqlite3_blob_reopen: 3.7.4 -blob = ["libsqlite3-sys/min_sqlite_version_3_7_16"] +blob = ["libsqlite3-sys/min_sqlite_version_3_7_7"] collation = [] # sqlite3_create_function_v2: 3.7.3 (2010-10-08) -functions = ["libsqlite3-sys/min_sqlite_version_3_7_16"] +# functions requires ffi::SQLITE_DETERMINISTIC: 3.8.3 (2014-02-03) +functions = ["modern_sqlite"] # sqlite3_log: 3.6.23 (2010-03-09) -trace = ["libsqlite3-sys/min_sqlite_version_3_7_16"] +trace = ["libsqlite3-sys/min_sqlite_version_3_6_23"] bundled = ["libsqlite3-sys/bundled", "modern_sqlite"] buildtime_bindgen = ["libsqlite3-sys/buildtime_bindgen"] loadable_extension = ["libsqlite3-sys/loadable_extension"] -loadable_extension_embedded = ["libsqlite3-sys/loadable_extension_embedded"] +loadable_extension_embedded = ["loadable_extension", "libsqlite3-sys/loadable_extension_embedded"] limits = [] hooks = [] i128_blob = ["byteorder"] -# when `sqlcipher` is used, `bundled` and `loadable_extension` are ignored sqlcipher = ["libsqlite3-sys/sqlcipher"] unlock_notify = ["libsqlite3-sys/unlock_notify"] # xSavepoint, xRelease and xRollbackTo: 3.7.7 (2011-06-23) -vtab = ["libsqlite3-sys/min_sqlite_version_3_7_16", "lazy_static"] +vtab = ["libsqlite3-sys/min_sqlite_version_3_7_7", "lazy_static"] csvtab = ["csv", "vtab"] # pointer passing interfaces: 3.20.0 -array = ["vtab"] +array = ["modern_sqlite", "vtab"] # session extension: 3.13.0 -session = ["libsqlite3-sys/session", "hooks"] +session = ["modern_sqlite", "libsqlite3-sys/session", "hooks"] # window functions: 3.25.0 -window = ["functions"] +window = ["modern_sqlite", "functions"] # 3.9.0 series = ["vtab"] # check for invalid query. diff --git a/README.md b/README.md index 75ad364fe..ed7798641 100644 --- a/README.md +++ b/README.md @@ -165,6 +165,8 @@ minimum SQLite version that supports your chosen features. If you are using pregenerated bindings are chosen: * `min_sqlite_version_3_6_8` - SQLite 3.6.8 bindings (this is the default) +* `min_sqlite_version_3_6_23` - SQLite 3.6.23 bindings +* `min_sqlite_version_3_7_7` - SQLite 3.7.7 bindings * `min_sqlite_version_3_7_16` - SQLite 3.7.16 bindings If you use the `bundled` feature, you will get pregenerated bindings for the diff --git a/dummy-extension/.gitignore b/dummy-extension/.gitignore new file mode 100644 index 000000000..5f0a3e16d --- /dev/null +++ b/dummy-extension/.gitignore @@ -0,0 +1,3 @@ +/target/ +/doc/ +Cargo.lock diff --git a/dummy-extension/Cargo.toml b/dummy-extension/Cargo.toml index c8096a544..b3d68e2de 100644 --- a/dummy-extension/Cargo.toml +++ b/dummy-extension/Cargo.toml @@ -18,3 +18,6 @@ path = ".." default-features = false features = ["loadable_extension", "vtab", "functions", "bundled"] version = "0.24.2" + +[workspace] +members = [] diff --git a/dummy-extension/integration-test.sh b/dummy-extension/integration-test.sh new file mode 100755 index 000000000..b1707622c --- /dev/null +++ b/dummy-extension/integration-test.sh @@ -0,0 +1,15 @@ +#!/bin/bash + +set -euf -o pipefail + +sqlite3_cmd=$(which sqlite3) +dummy_extension="dummy-extension/target/debug/libdummy_extension" # sqlite will try adding .so, .dll, .dylib to this on its own + +>&2 echo "running sqlite3 (${sqlite3_cmd}) to test loadable extension ${dummy_extension}" +output=$(sqlite3 -cmd ".load ${dummy_extension}" :memory: "SELECT value FROM dummy") + +>&2 echo "sqlite3 command returned output, checking it is as expected" +test "1" = "${output}" + +>&2 echo "OK" +exit 0 diff --git a/dummy-extension/src/lib.rs b/dummy-extension/src/lib.rs index ac66824f8..d76d1802f 100644 --- a/dummy-extension/src/lib.rs +++ b/dummy-extension/src/lib.rs @@ -103,12 +103,12 @@ unsafe impl VTabCursor for DummyTabCursor<'_> { fn dummy_init(db: *mut ffi::sqlite3) -> Result<()> { let conn = unsafe { Connection::from_handle(db)? }; - println!("initied dummy module {:?}", db); + eprintln!("inited dummy module {:?}", db); conn.create_scalar_function( "dummy_test_function", 0, FunctionFlags::SQLITE_DETERMINISTIC, - |ctx| { + |_ctx| { Ok(ToSqlOutput::Owned(Value::Text( "Loaded correctly!".to_string(), ))) diff --git a/libsqlite3-sys/Cargo.toml b/libsqlite3-sys/Cargo.toml index 345d7b247..f076ead73 100644 --- a/libsqlite3-sys/Cargo.toml +++ b/libsqlite3-sys/Cargo.toml @@ -14,14 +14,14 @@ categories = ["external-ffi-bindings"] [features] default = ["min_sqlite_version_3_6_8"] bundled = ["cc", "bundled_bindings"] -# allows a dependency to use `bundled` only on windows bundled-windows = ["cc", "bundled_bindings"] buildtime_bindgen = ["bindgen", "pkg-config", "vcpkg"] -loadable_extension = ["syn", "quote"] +loadable_extension = ["syn", "quote", "which"] loadable_extension_embedded = ["loadable_extension"] -# when `sqlcipher` is used, `bundled` and `loadable_extension` are ignored sqlcipher = [] min_sqlite_version_3_6_8 = ["pkg-config", "vcpkg"] +min_sqlite_version_3_6_23 = ["pkg-config", "vcpkg"] +min_sqlite_version_3_7_7 = ["pkg-config", "vcpkg"] min_sqlite_version_3_7_16 = ["pkg-config", "vcpkg"] # Bundle only the bindings file. Note that this does nothing if # `buildtime_bindgen` is enabled. @@ -39,11 +39,12 @@ wasm32-wasi-vfs = [] winsqlite3 = ["min_sqlite_version_3_7_16"] [build-dependencies] -bindgen = { version = "0.56", optional = true, default-features = false, features = ["runtime"] } +bindgen = { version = "0.57", optional = true, default-features = false, features = ["runtime"] } pkg-config = { version = "0.3", optional = true } cc = { version = "1.0", optional = true } syn = { version = "1.0", features = ["extra-traits", "full", "printing"], optional = true } quote = { version = "1.0", optional = true } +which = { version = "4.0.2", optional = true } [target.'cfg(target_env = "msvc")'.build-dependencies] vcpkg = { version = "0.2", optional = true } diff --git a/libsqlite3-sys/bindgen-bindings/README.md b/libsqlite3-sys/bindgen-bindings/README.md index 55c9d2007..2f64726a4 100644 --- a/libsqlite3-sys/bindgen-bindings/README.md +++ b/libsqlite3-sys/bindgen-bindings/README.md @@ -16,6 +16,8 @@ sqlite3 amalgamation source links --------------------------------- The location of the amalgamation sources used to build these are: - [3.7.16](https://sqlite.org/2013/sqlite-amalgamation-3071600.zip) + - [3.7.7](https://sqlite.org/sqlite-amalgamation-3070700.zip) + - [3.6.23](https://sqlite.org/sqlite-amalgamation-3_6_23.zip) - [3.6.8](https://sqlite.org/sqlite-amalgamation-3_6_8.zip) diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23-ext.rs new file mode 100644 index 000000000..65ddca3fc --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23-ext.rs @@ -0,0 +1,6839 @@ +/* automatically generated by rust-bindgen 0.57.0 */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.6.23\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3006023; +pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = + b"2010-03-09 19:31:43 4ae453ea7be69018d8c16eb8dabe05617397dc4d\0"; +pub const SQLITE_OK: i32 = 0; +pub const SQLITE_ERROR: i32 = 1; +pub const SQLITE_INTERNAL: i32 = 2; +pub const SQLITE_PERM: i32 = 3; +pub const SQLITE_ABORT: i32 = 4; +pub const SQLITE_BUSY: i32 = 5; +pub const SQLITE_LOCKED: i32 = 6; +pub const SQLITE_NOMEM: i32 = 7; +pub const SQLITE_READONLY: i32 = 8; +pub const SQLITE_INTERRUPT: i32 = 9; +pub const SQLITE_IOERR: i32 = 10; +pub const SQLITE_CORRUPT: i32 = 11; +pub const SQLITE_NOTFOUND: i32 = 12; +pub const SQLITE_FULL: i32 = 13; +pub const SQLITE_CANTOPEN: i32 = 14; +pub const SQLITE_PROTOCOL: i32 = 15; +pub const SQLITE_EMPTY: i32 = 16; +pub const SQLITE_SCHEMA: i32 = 17; +pub const SQLITE_TOOBIG: i32 = 18; +pub const SQLITE_CONSTRAINT: i32 = 19; +pub const SQLITE_MISMATCH: i32 = 20; +pub const SQLITE_MISUSE: i32 = 21; +pub const SQLITE_NOLFS: i32 = 22; +pub const SQLITE_AUTH: i32 = 23; +pub const SQLITE_FORMAT: i32 = 24; +pub const SQLITE_RANGE: i32 = 25; +pub const SQLITE_NOTADB: i32 = 26; +pub const SQLITE_ROW: i32 = 100; +pub const SQLITE_DONE: i32 = 101; +pub const SQLITE_IOERR_READ: i32 = 266; +pub const SQLITE_IOERR_SHORT_READ: i32 = 522; +pub const SQLITE_IOERR_WRITE: i32 = 778; +pub const SQLITE_IOERR_FSYNC: i32 = 1034; +pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; +pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; +pub const SQLITE_IOERR_FSTAT: i32 = 1802; +pub const SQLITE_IOERR_UNLOCK: i32 = 2058; +pub const SQLITE_IOERR_RDLOCK: i32 = 2314; +pub const SQLITE_IOERR_DELETE: i32 = 2570; +pub const SQLITE_IOERR_BLOCKED: i32 = 2826; +pub const SQLITE_IOERR_NOMEM: i32 = 3082; +pub const SQLITE_IOERR_ACCESS: i32 = 3338; +pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; +pub const SQLITE_IOERR_LOCK: i32 = 3850; +pub const SQLITE_IOERR_CLOSE: i32 = 4106; +pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; +pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; +pub const SQLITE_OPEN_READONLY: i32 = 1; +pub const SQLITE_OPEN_READWRITE: i32 = 2; +pub const SQLITE_OPEN_CREATE: i32 = 4; +pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; +pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; +pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; +pub const SQLITE_OPEN_MAIN_DB: i32 = 256; +pub const SQLITE_OPEN_TEMP_DB: i32 = 512; +pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; +pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; +pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; +pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; +pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; +pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; +pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; +pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; +pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; +pub const SQLITE_IOCAP_ATOMIC: i32 = 1; +pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; +pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; +pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; +pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; +pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; +pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; +pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; +pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; +pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; +pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; +pub const SQLITE_LOCK_NONE: i32 = 0; +pub const SQLITE_LOCK_SHARED: i32 = 1; +pub const SQLITE_LOCK_RESERVED: i32 = 2; +pub const SQLITE_LOCK_PENDING: i32 = 3; +pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; +pub const SQLITE_SYNC_NORMAL: i32 = 2; +pub const SQLITE_SYNC_FULL: i32 = 3; +pub const SQLITE_SYNC_DATAONLY: i32 = 16; +pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; +pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_LAST_ERRNO: i32 = 4; +pub const SQLITE_ACCESS_EXISTS: i32 = 0; +pub const SQLITE_ACCESS_READWRITE: i32 = 1; +pub const SQLITE_ACCESS_READ: i32 = 2; +pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; +pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; +pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; +pub const SQLITE_CONFIG_MALLOC: i32 = 4; +pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; +pub const SQLITE_CONFIG_SCRATCH: i32 = 6; +pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; +pub const SQLITE_CONFIG_HEAP: i32 = 8; +pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; +pub const SQLITE_CONFIG_MUTEX: i32 = 10; +pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; +pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; +pub const SQLITE_CONFIG_PCACHE: i32 = 14; +pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; +pub const SQLITE_CONFIG_LOG: i32 = 16; +pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; +pub const SQLITE_DENY: i32 = 1; +pub const SQLITE_IGNORE: i32 = 2; +pub const SQLITE_CREATE_INDEX: i32 = 1; +pub const SQLITE_CREATE_TABLE: i32 = 2; +pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; +pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; +pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; +pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; +pub const SQLITE_CREATE_TRIGGER: i32 = 7; +pub const SQLITE_CREATE_VIEW: i32 = 8; +pub const SQLITE_DELETE: i32 = 9; +pub const SQLITE_DROP_INDEX: i32 = 10; +pub const SQLITE_DROP_TABLE: i32 = 11; +pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; +pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; +pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; +pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; +pub const SQLITE_DROP_TRIGGER: i32 = 16; +pub const SQLITE_DROP_VIEW: i32 = 17; +pub const SQLITE_INSERT: i32 = 18; +pub const SQLITE_PRAGMA: i32 = 19; +pub const SQLITE_READ: i32 = 20; +pub const SQLITE_SELECT: i32 = 21; +pub const SQLITE_TRANSACTION: i32 = 22; +pub const SQLITE_UPDATE: i32 = 23; +pub const SQLITE_ATTACH: i32 = 24; +pub const SQLITE_DETACH: i32 = 25; +pub const SQLITE_ALTER_TABLE: i32 = 26; +pub const SQLITE_REINDEX: i32 = 27; +pub const SQLITE_ANALYZE: i32 = 28; +pub const SQLITE_CREATE_VTABLE: i32 = 29; +pub const SQLITE_DROP_VTABLE: i32 = 30; +pub const SQLITE_FUNCTION: i32 = 31; +pub const SQLITE_SAVEPOINT: i32 = 32; +pub const SQLITE_COPY: i32 = 0; +pub const SQLITE_LIMIT_LENGTH: i32 = 0; +pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; +pub const SQLITE_LIMIT_COLUMN: i32 = 2; +pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; +pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; +pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; +pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; +pub const SQLITE_LIMIT_ATTACHED: i32 = 7; +pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; +pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; +pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; +pub const SQLITE_INTEGER: i32 = 1; +pub const SQLITE_FLOAT: i32 = 2; +pub const SQLITE_BLOB: i32 = 4; +pub const SQLITE_NULL: i32 = 5; +pub const SQLITE_TEXT: i32 = 3; +pub const SQLITE3_TEXT: i32 = 3; +pub const SQLITE_UTF8: i32 = 1; +pub const SQLITE_UTF16LE: i32 = 2; +pub const SQLITE_UTF16BE: i32 = 3; +pub const SQLITE_UTF16: i32 = 4; +pub const SQLITE_ANY: i32 = 5; +pub const SQLITE_UTF16_ALIGNED: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; +pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; +pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; +pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; +pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; +pub const SQLITE_MUTEX_FAST: i32 = 0; +pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; +pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; +pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; +pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; +pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; +pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; +pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; +pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; +pub const SQLITE_TESTCTRL_FIRST: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; +pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; +pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; +pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; +pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; +pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; +pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; +pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; +pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; +pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; +pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; +pub const SQLITE_TESTCTRL_LAST: i32 = 16; +pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; +pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; +pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; +pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; +pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; +pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; +pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; +pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; +pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; +pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; +pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; +pub const SQLITE_STMTSTATUS_SORT: i32 = 2; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; +extern "C" { + pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3 { + _unused: [u8; 0], +} +pub type sqlite_int64 = ::std::os::raw::c_longlong; +pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; +pub type sqlite3_int64 = sqlite_int64; +pub type sqlite3_uint64 = sqlite_uint64; +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_file { + pub pMethods: *const sqlite3_io_methods, +} +#[test] +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vfs { + pub iVersion: ::std::os::raw::c_int, + pub szOsFile: ::std::os::raw::c_int, + pub mxPathname: ::std::os::raw::c_int, + pub pNext: *mut sqlite3_vfs, + pub zName: *const ::std::os::raw::c_char, + pub pAppData: *mut ::std::os::raw::c_void, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_vfs() { + assert_eq!( + ::std::mem::size_of::(), + 136usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mem_methods { + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub pAppData: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_mem_methods() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_stmt { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Mem { + _unused: [u8; 0], +} +pub type sqlite3_value = Mem; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_context { + _unused: [u8; 0], +} +pub type sqlite3_destructor_type = + ::std::option::Option; +extern "C" { + pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 160usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info { + pub nConstraint: ::std::os::raw::c_int, + pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, + pub nOrderBy: ::std::os::raw::c_int, + pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, + pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, + pub idxNum: ::std::os::raw::c_int, + pub idxStr: *mut ::std::os::raw::c_char, + pub needToFreeIdxStr: ::std::os::raw::c_int, + pub orderByConsumed: ::std::os::raw::c_int, + pub estimatedCost: f64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint { + pub iColumn: ::std::os::raw::c_int, + pub op: ::std::os::raw::c_uchar, + pub usable: ::std::os::raw::c_uchar, + pub iTermOffset: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_orderby { + pub iColumn: ::std::os::raw::c_int, + pub desc: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint_usage { + pub argvIndex: ::std::os::raw::c_int, + pub omit: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); +} +#[test] +fn bindgen_test_layout_sqlite3_index_info() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_blob { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex_methods { + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_mutex_methods() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods { + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_backup { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_api_routines { + pub aggregate_context: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub aggregate_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, + >, + pub bind_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_double: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int, + >, + pub bind_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, + ) -> ::std::os::raw::c_int, + >, + pub bind_null: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub bind_parameter_index: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub bind_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub busy_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub busy_timeout: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub changes: + ::std::option::Option ::std::os::raw::c_int>, + pub close: + ::std::option::Option ::std::os::raw::c_int>, + pub collation_needed: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub collation_needed16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub column_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_bytes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_bytes16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub column_database_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_database_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_decltype: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_decltype16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_double: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, + >, + pub column_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_int64: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, + >, + pub column_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_origin_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_origin_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_table_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_table_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar, + >, + pub column_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_type: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value, + >, + pub commit_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub complete: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub complete16: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub create_collation: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_collation16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_function16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_module: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub data_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub db_handle: + ::std::option::Option *mut sqlite3>, + pub declare_vtab: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub enable_shared_cache: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub errmsg: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, + >, + pub errmsg16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, + >, + pub exec: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub expired: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub finalize: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub free: ::std::option::Option, + pub free_table: + ::std::option::Option, + pub get_autocommit: + ::std::option::Option ::std::os::raw::c_int>, + pub get_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub get_table: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub global_recover: ::std::option::Option ::std::os::raw::c_int>, + pub interruptx: ::std::option::Option, + pub last_insert_rowid: + ::std::option::Option sqlite_int64>, + pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, + pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, + pub malloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub mprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub open16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub prepare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub profile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub progress_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ), + >, + pub realloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub result_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_double: + ::std::option::Option, + pub result_error: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_error16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_int64: + ::std::option::Option, + pub result_null: ::std::option::Option, + pub result_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16be: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16le: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_value: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), + >, + pub rollback_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub set_authorizer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub set_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, + ), + >, + pub snprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub step: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub table_column_metadata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub thread_cleanup: ::std::option::Option, + pub total_changes: + ::std::option::Option ::std::os::raw::c_int>, + pub trace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub transfer_bindings: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int, + >, + pub update_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub user_data: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, + >, + pub value_blob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_bytes16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_double: ::std::option::Option f64>, + pub value_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_int64: + ::std::option::Option sqlite_int64>, + pub value_numeric_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_text: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, + >, + pub value_text16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16be: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16le: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub vmprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub overload_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub prepare_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub clear_bindings: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub create_module_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_close: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int, + >, + pub blob_read: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_write: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub create_collation_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub file_control: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub memory_highwater: + ::std::option::Option sqlite3_int64>, + pub memory_used: ::std::option::Option sqlite3_int64>, + pub mutex_alloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub mutex_enter: ::std::option::Option, + pub mutex_free: ::std::option::Option, + pub mutex_leave: ::std::option::Option, + pub mutex_try: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub open_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub release_memory: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub result_error_nomem: ::std::option::Option, + pub result_error_toobig: + ::std::option::Option, + pub sleep: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub soft_heap_limit: ::std::option::Option, + pub vfs_find: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, + >, + pub vfs_register: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub vfs_unregister: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, + >, + pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, + pub result_zeroblob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_error_code: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub test_control: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, + >, + pub randomness: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), + >, + pub context_db_handle: + ::std::option::Option *mut sqlite3>, + pub extended_result_codes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub limit: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub next_stmt: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, + >, + pub sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, + >, + pub status: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_api_routines() { + assert_eq!( + ::std::mem::size_of::(), + 1240usize, + concat!("Size of: ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_context as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_context) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_count as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_double as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_count as *const _ + as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_index as *const _ + as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_index) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_name as *const _ + as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text16 as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_handler as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_handler) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_timeout as *const _ as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_timeout) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed as *const _ as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_blob as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes as *const _ as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize + }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_count as *const _ as usize + }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name as *const _ + as usize + }, + 184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name16 as *const _ + as usize + }, + 192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype as *const _ as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize + }, + 208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_double as *const _ as usize + }, + 216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, + 224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_int64 as *const _ as usize + }, + 232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name as *const _ as usize + }, + 240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name16 as *const _ as usize + }, + 248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name as *const _ as usize + }, + 256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name16 as *const _ + as usize + }, + 264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name as *const _ as usize + }, + 272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name16 as *const _ + as usize + }, + 280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text as *const _ as usize + }, + 288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text16 as *const _ as usize + }, + 296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_type as *const _ as usize + }, + 304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_type) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_value as *const _ as usize + }, + 312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).commit_hook as *const _ as usize + }, + 320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(commit_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, + 328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, + 336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation as *const _ as usize + }, + 344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation16 as *const _ as usize + }, + 352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function as *const _ as usize + }, + 360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function16 as *const _ as usize + }, + 368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module as *const _ as usize + }, + 376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, + 384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(data_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, + 392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).declare_vtab as *const _ as usize + }, + 400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(declare_vtab) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).enable_shared_cache as *const _ + as usize + }, + 408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(enable_shared_cache) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, + 416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, + 424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, + 432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, + 440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(exec) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, + 448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(expired) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, + 456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(finalize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, + 464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, + 472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_autocommit as *const _ as usize + }, + 480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_autocommit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_auxdata as *const _ as usize + }, + 488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, + 496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).global_recover as *const _ as usize + }, + 504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(global_recover) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, + 512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(interruptx) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize + }, + 520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(last_insert_rowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, + 528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).libversion_number as *const _ as usize + }, + 536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion_number) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, + 544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, + 552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, + 560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, + 568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, + 576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, + 584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, + 592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(profile) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).progress_handler as *const _ as usize + }, + 600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(progress_handler) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, + 608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, + 616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob as *const _ as usize + }, + 624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_double as *const _ as usize + }, + 632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_double) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error as *const _ as usize + }, + 640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error16 as *const _ as usize + }, + 648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, + 656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_int64 as *const _ as usize + }, + 664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_null as *const _ as usize + }, + 672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text as *const _ as usize + }, + 680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16 as *const _ as usize + }, + 688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16be as *const _ as usize + }, + 696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16le as *const _ as usize + }, + 704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16le) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_value as *const _ as usize + }, + 712usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rollback_hook as *const _ as usize + }, + 720usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(rollback_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_authorizer as *const _ as usize + }, + 728usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_authorizer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_auxdata as *const _ as usize + }, + 736usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).snprintf as *const _ as usize }, + 744usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(snprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, + 752usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).table_column_metadata as *const _ + as usize + }, + 760usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(table_column_metadata) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize + }, + 768usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(thread_cleanup) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).total_changes as *const _ as usize + }, + 776usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(total_changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, + 784usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(trace) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize + }, + 792usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(transfer_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).update_hook as *const _ as usize + }, + 800usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(update_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, + 808usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(user_data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, + 816usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes as *const _ as usize + }, + 824usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize + }, + 832usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_double as *const _ as usize + }, + 840usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, + 848usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_int64 as *const _ as usize + }, + 856usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize + }, + 864usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_numeric_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, + 872usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16 as *const _ as usize + }, + 880usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16be as *const _ as usize + }, + 888usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16le as *const _ as usize + }, + 896usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16le) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, + 904usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, + 912usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vmprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).overload_function as *const _ as usize + }, + 920usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(overload_function) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, + 928usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize + }, + 936usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).clear_bindings as *const _ as usize + }, + 944usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(clear_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize + }, + 952usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize + }, + 960usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, + 968usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_bytes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, + 976usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_close) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, + 984usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, + 992usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_read) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, + 1000usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_write) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation_v2 as *const _ + as usize + }, + 1008usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).file_control as *const _ as usize + }, + 1016usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(file_control) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_highwater as *const _ as usize + }, + 1024usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_highwater) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_used as *const _ as usize + }, + 1032usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize + }, + 1040usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_alloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_enter as *const _ as usize + }, + 1048usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_enter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, + 1056usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_leave as *const _ as usize + }, + 1064usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_leave) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, + 1072usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_try) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, + 1080usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).release_memory as *const _ as usize + }, + 1088usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(release_memory) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize + }, + 1096usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_nomem) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_toobig as *const _ + as usize + }, + 1104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_toobig) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, + 1112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sleep) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize + }, + 1120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, + 1128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_find) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_register as *const _ as usize + }, + 1136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_register) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize + }, + 1144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_unregister) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize + }, + 1152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xthreadsafe) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize + }, + 1160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_code as *const _ as usize + }, + 1168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_code) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).test_control as *const _ as usize + }, + 1176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(test_control) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, + 1184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(randomness) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).context_db_handle as *const _ as usize + }, + 1192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(context_db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_result_codes as *const _ + as usize + }, + 1200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_result_codes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, + 1208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, + 1216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(next_stmt) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, + 1224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sql) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, + 1232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status) + ) + ); +} +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} + +// sqlite3_api is defined in lib.rs as either a static or an extern when compiled as a loadable_extension +use crate::sqlite3_api; + +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) + +pub unsafe fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_context.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_context", + " function" + )))(arg1, nBytes) +} + +pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_double", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_null", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_index.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_index", + " function" + )))(arg1, zName) +} + +pub unsafe fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_value", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_handler", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_timeout.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_timeout", + " function" + )))(arg1, ms) +} + +pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_blob", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype", + " function" + )))(arg1, i) +} + +pub unsafe fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_double", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int64", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_type", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_value", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).commit_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "commit_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete16", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_create_collation( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_collation16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_function( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_function16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function16", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_module( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).data_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "data_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).declare_vtab.expect(stringify!( + "sqlite3_api contains null pointer for ", + "declare_vtab", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).enable_shared_cache.expect(stringify!( + "sqlite3_api contains null pointer for ", + "enable_shared_cache", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errcode", + " function" + )))(db) +} + +pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_exec( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).exec.expect(stringify!( + "sqlite3_api contains null pointer for ", + "exec", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).expired.expect(stringify!( + "sqlite3_api contains null pointer for ", + "expired", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).finalize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "finalize", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free_table", + " function" + )))(result) +} + +pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_autocommit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_autocommit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_auxdata", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_get_table( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_table", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).global_recover.expect(stringify!( + "sqlite3_api contains null pointer for ", + "global_recover", + " function" + )))() +} + +pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).interruptx.expect(stringify!( + "sqlite3_api contains null pointer for ", + "interruptx", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).last_insert_rowid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "last_insert_rowid", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion", + " function" + )))() +} + +pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion_number.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion_number", + " function" + )))() +} + +pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mprintf", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_open( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_open16( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_prepare( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_profile( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).profile.expect(stringify!( + "sqlite3_api contains null pointer for ", + "profile", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).progress_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "progress_handler", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_double", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_null", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16be", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16le", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_value", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).rollback_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "rollback_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_authorizer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_authorizer", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_auxdata", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_snprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).snprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "snprintf", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "step", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_table_column_metadata( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).table_column_metadata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "table_column_metadata", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) +} + +pub unsafe fn sqlite3_thread_cleanup() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).thread_cleanup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "thread_cleanup", + " function" + )))() +} + +pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).total_changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "total_changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).trace.expect(stringify!( + "sqlite3_api contains null pointer for ", + "trace", + " function" + )))(arg1, xTrace, arg2) +} + +pub unsafe fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).transfer_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "transfer_bindings", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).update_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "update_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).user_data.expect(stringify!( + "sqlite3_api contains null pointer for ", + "user_data", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_blob", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_double", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_numeric_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_numeric_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16be", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16le", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vmprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vmprintf", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).overload_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "overload_function", + " function" + )))(arg1, zFuncName, nArg) +} + +pub unsafe fn sqlite3_prepare_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).clear_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "clear_bindings", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_module_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module_v2", + " function" + )))(arg1, arg2, arg3, arg4, xDestroy) +} + +pub unsafe fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_open( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_open", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) +} + +pub unsafe fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_read.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_read", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_write.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_write", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_file_control( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).file_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "file_control", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_highwater.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_highwater", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_used", + " function" + )))() +} + +pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_alloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_alloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_enter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_enter", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_leave.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_leave", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_try.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_try", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_open_v2( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open_v2", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_nomem.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_nomem", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_toobig.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_toobig", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sleep.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sleep", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_find.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_find", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_register.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_register", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_unregister.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_unregister", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xthreadsafe.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xthreadsafe", + " function" + )))() +} + +pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_code.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_code", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_test_control(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).test_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "test_control", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).randomness.expect(stringify!( + "sqlite3_api contains null pointer for ", + "randomness", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).context_db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "context_db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_result_codes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_result_codes", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_limit( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "limit", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).next_stmt.expect(stringify!( + "sqlite3_api contains null pointer for ", + "next_stmt", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_status( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status", + " function" + )))(arg1, arg2, arg3, arg4) +} diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23.rs new file mode 100644 index 000000000..f10cdfa80 --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23.rs @@ -0,0 +1,3100 @@ +/* automatically generated by rust-bindgen 0.57.0 */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.6.23\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3006023; +pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = + b"2010-03-09 19:31:43 4ae453ea7be69018d8c16eb8dabe05617397dc4d\0"; +pub const SQLITE_OK: i32 = 0; +pub const SQLITE_ERROR: i32 = 1; +pub const SQLITE_INTERNAL: i32 = 2; +pub const SQLITE_PERM: i32 = 3; +pub const SQLITE_ABORT: i32 = 4; +pub const SQLITE_BUSY: i32 = 5; +pub const SQLITE_LOCKED: i32 = 6; +pub const SQLITE_NOMEM: i32 = 7; +pub const SQLITE_READONLY: i32 = 8; +pub const SQLITE_INTERRUPT: i32 = 9; +pub const SQLITE_IOERR: i32 = 10; +pub const SQLITE_CORRUPT: i32 = 11; +pub const SQLITE_NOTFOUND: i32 = 12; +pub const SQLITE_FULL: i32 = 13; +pub const SQLITE_CANTOPEN: i32 = 14; +pub const SQLITE_PROTOCOL: i32 = 15; +pub const SQLITE_EMPTY: i32 = 16; +pub const SQLITE_SCHEMA: i32 = 17; +pub const SQLITE_TOOBIG: i32 = 18; +pub const SQLITE_CONSTRAINT: i32 = 19; +pub const SQLITE_MISMATCH: i32 = 20; +pub const SQLITE_MISUSE: i32 = 21; +pub const SQLITE_NOLFS: i32 = 22; +pub const SQLITE_AUTH: i32 = 23; +pub const SQLITE_FORMAT: i32 = 24; +pub const SQLITE_RANGE: i32 = 25; +pub const SQLITE_NOTADB: i32 = 26; +pub const SQLITE_ROW: i32 = 100; +pub const SQLITE_DONE: i32 = 101; +pub const SQLITE_IOERR_READ: i32 = 266; +pub const SQLITE_IOERR_SHORT_READ: i32 = 522; +pub const SQLITE_IOERR_WRITE: i32 = 778; +pub const SQLITE_IOERR_FSYNC: i32 = 1034; +pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; +pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; +pub const SQLITE_IOERR_FSTAT: i32 = 1802; +pub const SQLITE_IOERR_UNLOCK: i32 = 2058; +pub const SQLITE_IOERR_RDLOCK: i32 = 2314; +pub const SQLITE_IOERR_DELETE: i32 = 2570; +pub const SQLITE_IOERR_BLOCKED: i32 = 2826; +pub const SQLITE_IOERR_NOMEM: i32 = 3082; +pub const SQLITE_IOERR_ACCESS: i32 = 3338; +pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; +pub const SQLITE_IOERR_LOCK: i32 = 3850; +pub const SQLITE_IOERR_CLOSE: i32 = 4106; +pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; +pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; +pub const SQLITE_OPEN_READONLY: i32 = 1; +pub const SQLITE_OPEN_READWRITE: i32 = 2; +pub const SQLITE_OPEN_CREATE: i32 = 4; +pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; +pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; +pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; +pub const SQLITE_OPEN_MAIN_DB: i32 = 256; +pub const SQLITE_OPEN_TEMP_DB: i32 = 512; +pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; +pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; +pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; +pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; +pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; +pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; +pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; +pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; +pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; +pub const SQLITE_IOCAP_ATOMIC: i32 = 1; +pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; +pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; +pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; +pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; +pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; +pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; +pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; +pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; +pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; +pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; +pub const SQLITE_LOCK_NONE: i32 = 0; +pub const SQLITE_LOCK_SHARED: i32 = 1; +pub const SQLITE_LOCK_RESERVED: i32 = 2; +pub const SQLITE_LOCK_PENDING: i32 = 3; +pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; +pub const SQLITE_SYNC_NORMAL: i32 = 2; +pub const SQLITE_SYNC_FULL: i32 = 3; +pub const SQLITE_SYNC_DATAONLY: i32 = 16; +pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; +pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_LAST_ERRNO: i32 = 4; +pub const SQLITE_ACCESS_EXISTS: i32 = 0; +pub const SQLITE_ACCESS_READWRITE: i32 = 1; +pub const SQLITE_ACCESS_READ: i32 = 2; +pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; +pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; +pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; +pub const SQLITE_CONFIG_MALLOC: i32 = 4; +pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; +pub const SQLITE_CONFIG_SCRATCH: i32 = 6; +pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; +pub const SQLITE_CONFIG_HEAP: i32 = 8; +pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; +pub const SQLITE_CONFIG_MUTEX: i32 = 10; +pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; +pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; +pub const SQLITE_CONFIG_PCACHE: i32 = 14; +pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; +pub const SQLITE_CONFIG_LOG: i32 = 16; +pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; +pub const SQLITE_DENY: i32 = 1; +pub const SQLITE_IGNORE: i32 = 2; +pub const SQLITE_CREATE_INDEX: i32 = 1; +pub const SQLITE_CREATE_TABLE: i32 = 2; +pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; +pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; +pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; +pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; +pub const SQLITE_CREATE_TRIGGER: i32 = 7; +pub const SQLITE_CREATE_VIEW: i32 = 8; +pub const SQLITE_DELETE: i32 = 9; +pub const SQLITE_DROP_INDEX: i32 = 10; +pub const SQLITE_DROP_TABLE: i32 = 11; +pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; +pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; +pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; +pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; +pub const SQLITE_DROP_TRIGGER: i32 = 16; +pub const SQLITE_DROP_VIEW: i32 = 17; +pub const SQLITE_INSERT: i32 = 18; +pub const SQLITE_PRAGMA: i32 = 19; +pub const SQLITE_READ: i32 = 20; +pub const SQLITE_SELECT: i32 = 21; +pub const SQLITE_TRANSACTION: i32 = 22; +pub const SQLITE_UPDATE: i32 = 23; +pub const SQLITE_ATTACH: i32 = 24; +pub const SQLITE_DETACH: i32 = 25; +pub const SQLITE_ALTER_TABLE: i32 = 26; +pub const SQLITE_REINDEX: i32 = 27; +pub const SQLITE_ANALYZE: i32 = 28; +pub const SQLITE_CREATE_VTABLE: i32 = 29; +pub const SQLITE_DROP_VTABLE: i32 = 30; +pub const SQLITE_FUNCTION: i32 = 31; +pub const SQLITE_SAVEPOINT: i32 = 32; +pub const SQLITE_COPY: i32 = 0; +pub const SQLITE_LIMIT_LENGTH: i32 = 0; +pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; +pub const SQLITE_LIMIT_COLUMN: i32 = 2; +pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; +pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; +pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; +pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; +pub const SQLITE_LIMIT_ATTACHED: i32 = 7; +pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; +pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; +pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; +pub const SQLITE_INTEGER: i32 = 1; +pub const SQLITE_FLOAT: i32 = 2; +pub const SQLITE_BLOB: i32 = 4; +pub const SQLITE_NULL: i32 = 5; +pub const SQLITE_TEXT: i32 = 3; +pub const SQLITE3_TEXT: i32 = 3; +pub const SQLITE_UTF8: i32 = 1; +pub const SQLITE_UTF16LE: i32 = 2; +pub const SQLITE_UTF16BE: i32 = 3; +pub const SQLITE_UTF16: i32 = 4; +pub const SQLITE_ANY: i32 = 5; +pub const SQLITE_UTF16_ALIGNED: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; +pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; +pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; +pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; +pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; +pub const SQLITE_MUTEX_FAST: i32 = 0; +pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; +pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; +pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; +pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; +pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; +pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; +pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; +pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; +pub const SQLITE_TESTCTRL_FIRST: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; +pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; +pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; +pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; +pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; +pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; +pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; +pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; +pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; +pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; +pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; +pub const SQLITE_TESTCTRL_LAST: i32 = 16; +pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; +pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; +pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; +pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; +pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; +pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; +pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; +pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; +pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; +pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; +pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; +pub const SQLITE_STMTSTATUS_SORT: i32 = 2; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; +extern "C" { + pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; +} +extern "C" { + pub fn sqlite3_libversion() -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_sourceid() -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_libversion_number() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_compileoption_used( + zOptName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_compileoption_get(N: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_threadsafe() -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3 { + _unused: [u8; 0], +} +pub type sqlite_int64 = ::std::os::raw::c_longlong; +pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; +pub type sqlite3_int64 = sqlite_int64; +pub type sqlite3_uint64 = sqlite_uint64; +extern "C" { + pub fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +extern "C" { + pub fn sqlite3_exec( + arg1: *mut sqlite3, + sql: *const ::std::os::raw::c_char, + callback: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg2: *mut ::std::os::raw::c_void, + errmsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_file { + pub pMethods: *const sqlite3_io_methods, +} +#[test] +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vfs { + pub iVersion: ::std::os::raw::c_int, + pub szOsFile: ::std::os::raw::c_int, + pub mxPathname: ::std::os::raw::c_int, + pub pNext: *mut sqlite3_vfs, + pub zName: *const ::std::os::raw::c_char, + pub pAppData: *mut ::std::os::raw::c_void, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_vfs() { + assert_eq!( + ::std::mem::size_of::(), + 136usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); +} +extern "C" { + pub fn sqlite3_initialize() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_shutdown() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_os_init() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_os_end() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_db_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mem_methods { + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub pAppData: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_mem_methods() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +extern "C" { + pub fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + onoff: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_interrupt(arg1: *mut sqlite3); +} +extern "C" { + pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_get_table( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + pazResult: *mut *mut *mut ::std::os::raw::c_char, + pnRow: *mut ::std::os::raw::c_int, + pnColumn: *mut ::std::os::raw::c_int, + pzErrmsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char); +} +extern "C" { + pub fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char, ...) + -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_snprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_free(arg1: *mut ::std::os::raw::c_void); +} +extern "C" { + pub fn sqlite3_memory_used() -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_randomness(N: ::std::os::raw::c_int, P: *mut ::std::os::raw::c_void); +} +extern "C" { + pub fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + xAuth: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pUserData: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_profile( + arg1: *mut sqlite3, + xProfile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + pub fn sqlite3_open( + filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_open16( + filename: *const ::std::os::raw::c_void, + ppDb: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_open_v2( + filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3, + flags: ::std::os::raw::c_int, + zVfs: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_extended_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_stmt { + _unused: [u8; 0], +} +extern "C" { + pub fn sqlite3_limit( + arg1: *mut sqlite3, + id: ::std::os::raw::c_int, + newVal: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_prepare( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_prepare_v2( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_prepare16( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_prepare16_v2( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Mem { + _unused: [u8; 0], +} +pub type sqlite3_value = Mem; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_context { + _unused: [u8; 0], +} +extern "C" { + pub fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_int64, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64; +} +extern "C" { + pub fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar; +} +extern "C" { + pub fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value; +} +extern "C" { + pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function16( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_void, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_global_recover() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_thread_cleanup(); +} +extern "C" { + pub fn sqlite3_memory_alarm( + arg1: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_int64, + arg3: ::std::os::raw::c_int, + ), + >, + arg2: *mut ::std::os::raw::c_void, + arg3: sqlite3_int64, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64; +} +extern "C" { + pub fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar; +} +extern "C" { + pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3; +} +extern "C" { + pub fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option, + ); +} +pub type sqlite3_destructor_type = + ::std::option::Option; +extern "C" { + pub fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64); +} +extern "C" { + pub fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context); +} +extern "C" { + pub fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context); +} +extern "C" { + pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite3_int64); +} +extern "C" { + pub fn sqlite3_result_null(arg1: *mut sqlite3_context); +} +extern "C" { + pub fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value); +} +extern "C" { + pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, n: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_create_collation( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation16( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_void, + eTextRep: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3; +} +extern "C" { + pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) -> *mut sqlite3_stmt; +} +extern "C" { + pub fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_table_column_metadata( + db: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + zTableName: *const ::std::os::raw::c_char, + zColumnName: *const ::std::os::raw::c_char, + pzDataType: *mut *const ::std::os::raw::c_char, + pzCollSeq: *mut *const ::std::os::raw::c_char, + pNotNull: *mut ::std::os::raw::c_int, + pPrimaryKey: *mut ::std::os::raw::c_int, + pAutoinc: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_load_extension( + db: *mut sqlite3, + zFile: *const ::std::os::raw::c_char, + zProc: *const ::std::os::raw::c_char, + pzErrMsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_enable_load_extension( + db: *mut sqlite3, + onoff: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_auto_extension( + xEntryPoint: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_reset_auto_extension(); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 160usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info { + pub nConstraint: ::std::os::raw::c_int, + pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, + pub nOrderBy: ::std::os::raw::c_int, + pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, + pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, + pub idxNum: ::std::os::raw::c_int, + pub idxStr: *mut ::std::os::raw::c_char, + pub needToFreeIdxStr: ::std::os::raw::c_int, + pub orderByConsumed: ::std::os::raw::c_int, + pub estimatedCost: f64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint { + pub iColumn: ::std::os::raw::c_int, + pub op: ::std::os::raw::c_uchar, + pub usable: ::std::os::raw::c_uchar, + pub iTermOffset: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_orderby { + pub iColumn: ::std::os::raw::c_int, + pub desc: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint_usage { + pub argvIndex: ::std::os::raw::c_int, + pub omit: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); +} +#[test] +fn bindgen_test_layout_sqlite3_index_info() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); +} +extern "C" { + pub fn sqlite3_create_module( + db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + p: *const sqlite3_module, + pClientData: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_module_v2( + db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + p: *const sqlite3_module, + pClientData: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +extern "C" { + pub fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + zSQL: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_blob { + _unused: [u8; 0], +} +extern "C" { + pub fn sqlite3_blob_open( + arg1: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + zTable: *const ::std::os::raw::c_char, + zColumn: *const ::std::os::raw::c_char, + iRow: sqlite3_int64, + flags: ::std::os::raw::c_int, + ppBlob: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + Z: *mut ::std::os::raw::c_void, + N: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + z: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs; +} +extern "C" { + pub fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + makeDflt: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex; +} +extern "C" { + pub fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex); +} +extern "C" { + pub fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex); +} +extern "C" { + pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex_methods { + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_mutex_methods() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +extern "C" { + pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex; +} +extern "C" { + pub fn sqlite3_file_control( + arg1: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + op: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_status( + op: ::std::os::raw::c_int, + pCurrent: *mut ::std::os::raw::c_int, + pHighwater: *mut ::std::os::raw::c_int, + resetFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_db_status( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + pCur: *mut ::std::os::raw::c_int, + pHiwtr: *mut ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_stmt_status( + arg1: *mut sqlite3_stmt, + op: ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods { + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_backup { + _unused: [u8; 0], +} +extern "C" { + pub fn sqlite3_backup_init( + pDest: *mut sqlite3, + zDestName: *const ::std::os::raw::c_char, + pSource: *mut sqlite3, + zSourceName: *const ::std::os::raw::c_char, + ) -> *mut sqlite3_backup; +} +extern "C" { + pub fn sqlite3_backup_step( + p: *mut sqlite3_backup, + nPage: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_backup_finish(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_backup_remaining(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_backup_pagecount(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_unlock_notify( + pBlocked: *mut sqlite3, + xNotify: ::std::option::Option< + unsafe extern "C" fn( + apArg: *mut *mut ::std::os::raw::c_void, + nArg: ::std::os::raw::c_int, + ), + >, + pNotifyArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_strnicmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_log( + iErrCode: ::std::os::raw::c_int, + zFormat: *const ::std::os::raw::c_char, + ... + ); +} +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs index 97bb8b349..cd9c2b5d3 100644 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs @@ -1,5 +1,6 @@ -/* automatically generated by rust-bindgen */ +/* automatically generated by rust-bindgen 0.57.0 */ +pub const __GNUC_VA_LIST: i32 = 1; pub const SQLITE_VERSION: &'static [u8; 6usize] = b"3.6.8\0"; pub const SQLITE_VERSION_NUMBER: i32 = 3006008; pub const SQLITE_OK: i32 = 0; @@ -192,8 +193,9 @@ pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; pub const SQLITE_STMTSTATUS_SORT: i32 = 2; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; extern "C" { - #[link_name = "\u{1}sqlite3_version"] pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; } #[repr(C)] @@ -888,7 +890,6 @@ pub struct sqlite3_context { pub type sqlite3_destructor_type = ::std::option::Option; extern "C" { - #[link_name = "\u{1}sqlite3_temp_directory"] pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; } #[repr(C)] @@ -2626,6 +2627,12 @@ pub struct sqlite3_api_routines { pub value_type: ::std::option::Option< unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, >, + pub vmprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, pub overload_function: ::std::option::Option< unsafe extern "C" fn( arg1: *mut sqlite3, @@ -2818,7 +2825,7 @@ pub struct sqlite3_api_routines { fn bindgen_test_layout_sqlite3_api_routines() { assert_eq!( ::std::mem::size_of::(), - 1232usize, + 1240usize, concat!("Size of: ", stringify!(sqlite3_api_routines)) ); assert_eq!( @@ -4119,6 +4126,16 @@ fn bindgen_test_layout_sqlite3_api_routines() { stringify!(value_type) ) ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, + 912usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vmprintf) + ) + ); assert_eq!( unsafe { &(*(::std::ptr::null::())).overload_function as *const _ as usize @@ -4571,9 +4588,70 @@ fn bindgen_test_layout_sqlite3_api_routines() { ) ); } +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} // sqlite3_api is defined in lib.rs as either a static or an extern when compiled as a loadable_extension -#[cfg(feature = "loadable_extension")] use crate::sqlite3_api; // sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) @@ -5574,10 +5652,7 @@ pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw )))(arg1) } -pub unsafe fn sqlite3_mprintf( - arg1: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { +pub unsafe fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char { if sqlite3_api.is_null() { panic!("sqlite3_api is null"); } @@ -5585,7 +5660,7 @@ pub unsafe fn sqlite3_mprintf( "sqlite3_api contains null pointer for ", "mprintf", " function" - )))(arg1, vararg1) + )))(arg1) } pub unsafe fn sqlite3_open( @@ -5938,7 +6013,6 @@ pub unsafe fn sqlite3_snprintf( arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_char, arg3: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, ) -> *mut ::std::os::raw::c_char { if sqlite3_api.is_null() { panic!("sqlite3_api is null"); @@ -5947,7 +6021,7 @@ pub unsafe fn sqlite3_snprintf( "sqlite3_api contains null pointer for ", "snprintf", " function" - )))(arg1, arg2, arg3, vararg1) + )))(arg1, arg2, arg3) } pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { @@ -6204,6 +6278,20 @@ pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_ )))(arg1) } +pub unsafe fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vmprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vmprintf", + " function" + )))(arg1, arg2) +} + pub unsafe fn sqlite3_overload_function( arg1: *mut sqlite3, zFuncName: *const ::std::os::raw::c_char, @@ -6628,10 +6716,7 @@ pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std: )))(arg1, arg2) } -pub unsafe fn sqlite3_test_control( - arg1: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { +pub unsafe fn sqlite3_test_control(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { if sqlite3_api.is_null() { panic!("sqlite3_api is null"); } @@ -6639,7 +6724,7 @@ pub unsafe fn sqlite3_test_control( "sqlite3_api contains null pointer for ", "test_control", " function" - )))(arg1, vararg1) + )))(arg1) } pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { @@ -6730,5 +6815,3 @@ pub unsafe fn sqlite3_status( " function" )))(arg1, arg2, arg3, arg4) } - -pub const SQLITE_DETERMINISTIC: i32 = 2048; diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8.rs index 3cd6b15d6..f0ea89d4b 100644 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8.rs +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8.rs @@ -1,7 +1,7 @@ -/* automatically generated by rust-bindgen */ +/* automatically generated by rust-bindgen 0.57.0 */ pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 6usize] = b"3.6.8\x00"; +pub const SQLITE_VERSION: &'static [u8; 6usize] = b"3.6.8\0"; pub const SQLITE_VERSION_NUMBER: i32 = 3006008; pub const SQLITE_OK: i32 = 0; pub const SQLITE_ERROR: i32 = 1; @@ -196,7 +196,6 @@ pub const SQLITE_STMTSTATUS_SORT: i32 = 2; pub type va_list = __builtin_va_list; pub type __gnuc_va_list = __builtin_va_list; extern "C" { - #[link_name = "sqlite3_version"] pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; } extern "C" { @@ -210,7 +209,9 @@ extern "C" { } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3([u8; 0]); +pub struct sqlite3 { + _unused: [u8; 0], +} pub type sqlite_int64 = ::std::os::raw::c_longlong; pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; pub type sqlite3_int64 = sqlite_int64; @@ -218,133 +219,283 @@ pub type sqlite3_uint64 = sqlite_uint64; extern "C" { pub fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int; } -pub type sqlite3_callback = - ::std::option::Option ::std::os::raw::c_int>; -extern "C" { - pub fn sqlite3_exec(arg1: *mut sqlite3, - sql: *const ::std::os::raw::c_char, - callback: - ::std::option::Option - ::std::os::raw::c_int>, - arg2: *mut ::std::os::raw::c_void, - errmsg: *mut *mut ::std::os::raw::c_char) - -> ::std::os::raw::c_int; +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +extern "C" { + pub fn sqlite3_exec( + arg1: *mut sqlite3, + sql: *const ::std::os::raw::c_char, + callback: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg2: *mut ::std::os::raw::c_void, + errmsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_file { - pub pMethods: *const sqlite3_file_sqlite3_io_methods, -} -#[repr(C)] -#[derive(Debug, Copy)] -pub struct sqlite3_file_sqlite3_io_methods { - pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option ::std::os::raw::c_int>, - pub xRead: ::std::option::Option ::std::os::raw::c_int>, - pub xWrite: ::std::option::Option ::std::os::raw::c_int>, - pub xTruncate: ::std::option::Option ::std::os::raw::c_int>, - pub xSync: ::std::option::Option ::std::os::raw::c_int>, - pub xFileSize: ::std::option::Option ::std::os::raw::c_int>, - pub xLock: ::std::option::Option ::std::os::raw::c_int>, - pub xUnlock: ::std::option::Option ::std::os::raw::c_int>, - pub xCheckReservedLock: ::std::option::Option - ::std::os::raw::c_int>, - pub xFileControl: ::std::option::Option ::std::os::raw::c_int>, - pub xSectorSize: ::std::option::Option ::std::os::raw::c_int>, - pub xDeviceCharacteristics: ::std::option::Option - ::std::os::raw::c_int>, + pub pMethods: *const sqlite3_io_methods, } #[test] -fn bindgen_test_layout_sqlite3_file_sqlite3_io_methods() { - assert_eq!(::std::mem::size_of::() , - 104usize); - assert_eq!(::std::mem::align_of::() , - 8usize); +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); } -impl Clone for sqlite3_file_sqlite3_io_methods { - fn clone(&self) -> Self { *self } +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, } #[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!(::std::mem::size_of::() , 8usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_file { - fn clone(&self) -> Self { *self } +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); } -pub type sqlite3_io_methods = sqlite3_file_sqlite3_io_methods; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex([u8; 0]); +pub struct sqlite3_mutex { + _unused: [u8; 0], +} #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_vfs { pub iVersion: ::std::os::raw::c_int, pub szOsFile: ::std::os::raw::c_int, @@ -352,97 +503,283 @@ pub struct sqlite3_vfs { pub pNext: *mut sqlite3_vfs, pub zName: *const ::std::os::raw::c_char, pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option ::std::os::raw::c_int>, - pub xDelete: ::std::option::Option ::std::os::raw::c_int>, - pub xAccess: ::std::option::Option ::std::os::raw::c_int>, - pub xFullPathname: ::std::option::Option ::std::os::raw::c_int>, - pub xDlOpen: ::std::option::Option *mut ::std::os::raw::c_void>, - pub xDlError: ::std::option::Option, - pub xDlSym: ::std::option::Option - ::std::option::Option>, - pub xDlClose: ::std::option::Option, - pub xRandomness: ::std::option::Option ::std::os::raw::c_int>, - pub xSleep: ::std::option::Option ::std::os::raw::c_int>, - pub xCurrentTime: ::std::option::Option ::std::os::raw::c_int>, - pub xGetLastError: ::std::option::Option ::std::os::raw::c_int>, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, } #[test] fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!(::std::mem::size_of::() , 136usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_vfs { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 136usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); } extern "C" { pub fn sqlite3_initialize() -> ::std::os::raw::c_int; @@ -457,52 +794,138 @@ extern "C" { pub fn sqlite3_os_end() -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) - -> ::std::os::raw::c_int; + pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_db_config(arg1: *mut sqlite3, - op: ::std::os::raw::c_int, ...) - -> ::std::os::raw::c_int; + pub fn sqlite3_db_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option *mut ::std::os::raw::c_void>, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option *mut ::std::os::raw::c_void>, - pub xSize: ::std::option::Option ::std::os::raw::c_int>, - pub xRoundup: ::std::option::Option ::std::os::raw::c_int>, - pub xInit: ::std::option::Option ::std::os::raw::c_int>, - pub xShutdown: ::std::option::Option, + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, pub pAppData: *mut ::std::os::raw::c_void, } #[test] fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!(::std::mem::size_of::() , 64usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_mem_methods { - fn clone(&self) -> Self { *self } -} -extern "C" { - pub fn sqlite3_extended_result_codes(arg1: *mut sqlite3, - onoff: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +extern "C" { + pub fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + onoff: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite3_int64; @@ -517,64 +940,68 @@ extern "C" { pub fn sqlite3_interrupt(arg1: *mut sqlite3); } extern "C" { - pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_busy_handler(arg1: *mut sqlite3, - arg2: - ::std::option::Option - ::std::os::raw::c_int>, - arg3: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_busy_timeout(arg1: *mut sqlite3, ms: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_get_table(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - pazResult: *mut *mut *mut ::std::os::raw::c_char, - pnRow: *mut ::std::os::raw::c_int, - pnColumn: *mut ::std::os::raw::c_int, - pzErrmsg: *mut *mut ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_get_table( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + pazResult: *mut *mut *mut ::std::os::raw::c_char, + pnRow: *mut ::std::os::raw::c_int, + pnColumn: *mut ::std::os::raw::c_int, + pzErrmsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char); } extern "C" { pub fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char, ...) - -> *mut ::std::os::raw::c_char; + -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_vmprintf(arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag) - -> *mut ::std::os::raw::c_char; + pub fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_snprintf(arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, ...) - -> *mut ::std::os::raw::c_char; + pub fn sqlite3_snprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_realloc(arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; } extern "C" { pub fn sqlite3_free(arg1: *mut ::std::os::raw::c_void); @@ -583,406 +1010,433 @@ extern "C" { pub fn sqlite3_memory_used() -> sqlite3_int64; } extern "C" { - pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) - -> sqlite3_int64; + pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) -> sqlite3_int64; } extern "C" { - pub fn sqlite3_randomness(N: ::std::os::raw::c_int, - P: *mut ::std::os::raw::c_void); + pub fn sqlite3_randomness(N: ::std::os::raw::c_int, P: *mut ::std::os::raw::c_void); } extern "C" { - pub fn sqlite3_set_authorizer(arg1: *mut sqlite3, - xAuth: - ::std::option::Option - ::std::os::raw::c_int>, - pUserData: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + xAuth: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pUserData: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_trace(arg1: *mut sqlite3, - xTrace: - ::std::option::Option, - arg2: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_profile(arg1: *mut sqlite3, - xProfile: - ::std::option::Option, - arg2: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_profile( + arg1: *mut sqlite3, + xProfile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_progress_handler(arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: - ::std::option::Option - ::std::os::raw::c_int>, - arg4: *mut ::std::os::raw::c_void); + pub fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ); } extern "C" { - pub fn sqlite3_open(filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3) -> ::std::os::raw::c_int; + pub fn sqlite3_open( + filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_open16(filename: *const ::std::os::raw::c_void, - ppDb: *mut *mut sqlite3) -> ::std::os::raw::c_int; + pub fn sqlite3_open16( + filename: *const ::std::os::raw::c_void, + ppDb: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_open_v2(filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3, - flags: ::std::os::raw::c_int, - zVfs: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_open_v2( + filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3, + flags: ::std::os::raw::c_int, + zVfs: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_extended_errcode(db: *mut sqlite3) - -> ::std::os::raw::c_int; + pub fn sqlite3_extended_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_errmsg(arg1: *mut sqlite3) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_errmsg16(arg1: *mut sqlite3) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt([u8; 0]); +pub struct sqlite3_stmt { + _unused: [u8; 0], +} extern "C" { - pub fn sqlite3_limit(arg1: *mut sqlite3, id: ::std::os::raw::c_int, - newVal: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_limit( + arg1: *mut sqlite3, + id: ::std::os::raw::c_int, + newVal: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_prepare( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare_v2(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_prepare_v2( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare16(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_prepare16( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare16_v2(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_prepare16_v2( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct Mem([u8; 0]); +pub struct Mem { + _unused: [u8; 0], +} pub type sqlite3_value = Mem; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_context([u8; 0]); +pub struct sqlite3_context { + _unused: [u8; 0], +} extern "C" { - pub fn sqlite3_bind_blob(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: - ::std::option::Option) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_double(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, arg3: f64) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_int(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_int64(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_int64) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_int64, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_null(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_text(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: - ::std::option::Option) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_text16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: - ::std::option::Option) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_value(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_zeroblob(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - n: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_parameter_name(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_bind_parameter_index(arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_name(arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_name16(arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_database_name(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_database_name16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_table_name(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_table_name16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_origin_name(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_origin_name16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_decltype(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_decltype16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { pub fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_blob(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_bytes(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_bytes16(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) -> f64; + pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64; } extern "C" { - pub fn sqlite3_column_int(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_int64(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) -> sqlite3_int64; + pub fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> sqlite3_int64; } extern "C" { - pub fn sqlite3_column_text(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_uchar; + pub fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar; } extern "C" { - pub fn sqlite3_column_text16(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_type(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_value(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> *mut sqlite3_value; + pub fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value; } extern "C" { - pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_create_function(db: *mut sqlite3, - zFunctionName: - *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: - ::std::option::Option, - xStep: - ::std::option::Option, - xFinal: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function16(db: *mut sqlite3, - zFunctionName: - *const ::std::os::raw::c_void, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: - ::std::option::Option, - xStep: - ::std::option::Option, - xFinal: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) - -> ::std::os::raw::c_int; + pub fn sqlite3_create_function( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function16( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_void, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_transfer_bindings(arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_global_recover() -> ::std::os::raw::c_int; @@ -991,111 +1445,106 @@ extern "C" { pub fn sqlite3_thread_cleanup(); } extern "C" { - pub fn sqlite3_memory_alarm(arg1: - ::std::option::Option, - arg2: *mut ::std::os::raw::c_void, - arg3: sqlite3_int64) -> ::std::os::raw::c_int; + pub fn sqlite3_memory_alarm( + arg1: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_int64, + arg3: ::std::os::raw::c_int, + ), + >, + arg2: *mut ::std::os::raw::c_void, + arg3: sqlite3_int64, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64; } extern "C" { - pub fn sqlite3_value_int(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite3_int64; } extern "C" { - pub fn sqlite3_value_text(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_uchar; + pub fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar; } extern "C" { - pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_type(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_aggregate_context(arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_user_data(arg1: *mut sqlite3_context) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) - -> *mut sqlite3; + pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3; } extern "C" { - pub fn sqlite3_get_auxdata(arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_set_auxdata(arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - arg3: - ::std::option::Option); + pub fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option, + ); } pub type sqlite3_destructor_type = - ::std::option::Option; + ::std::option::Option; extern "C" { - pub fn sqlite3_result_blob(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); + pub fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); } extern "C" { pub fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64); } extern "C" { - pub fn sqlite3_result_error(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int); + pub fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ); } extern "C" { - pub fn sqlite3_result_error16(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int); + pub fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ); } extern "C" { pub fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context); @@ -1104,280 +1553,569 @@ extern "C" { pub fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context); } extern "C" { - pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int); + pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_result_int(arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int); + pub fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, - arg2: sqlite3_int64); + pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite3_int64); } extern "C" { pub fn sqlite3_result_null(arg1: *mut sqlite3_context); } extern "C" { - pub fn sqlite3_result_text(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); -} -extern "C" { - pub fn sqlite3_result_text16(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); -} -extern "C" { - pub fn sqlite3_result_text16le(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); -} -extern "C" { - pub fn sqlite3_result_text16be(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); -} -extern "C" { - pub fn sqlite3_result_value(arg1: *mut sqlite3_context, - arg2: *mut sqlite3_value); -} -extern "C" { - pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, - n: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_create_collation(arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - xCompare: - ::std::option::Option - ::std::os::raw::c_int>) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation_v2(arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - xCompare: - ::std::option::Option - ::std::os::raw::c_int>, - xDestroy: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation16(arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_void, - eTextRep: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - xCompare: - ::std::option::Option - ::std::os::raw::c_int>) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed(arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed16(arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_key(db: *mut sqlite3, pKey: *const ::std::os::raw::c_void, - nKey: ::std::os::raw::c_int) -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_rekey(db: *mut sqlite3, - pKey: *const ::std::os::raw::c_void, - nKey: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; -} -extern "C" { - #[link_name = "sqlite3_temp_directory"] + pub fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value); +} +extern "C" { + pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, n: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_create_collation( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation16( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_void, + eTextRep: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_key( + db: *mut sqlite3, + pKey: *const ::std::os::raw::c_void, + nKey: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_rekey( + db: *mut sqlite3, + pKey: *const ::std::os::raw::c_void, + nKey: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) - -> ::std::os::raw::c_int; + pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3; } extern "C" { - pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) - -> *mut sqlite3_stmt; + pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) -> *mut sqlite3_stmt; } extern "C" { - pub fn sqlite3_commit_hook(arg1: *mut sqlite3, - arg2: - ::std::option::Option - ::std::os::raw::c_int>, - arg3: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_rollback_hook(arg1: *mut sqlite3, - arg2: - ::std::option::Option, - arg3: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_update_hook(arg1: *mut sqlite3, - arg2: - ::std::option::Option, - arg3: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_table_column_metadata(db: *mut sqlite3, - zDbName: - *const ::std::os::raw::c_char, - zTableName: - *const ::std::os::raw::c_char, - zColumnName: - *const ::std::os::raw::c_char, - pzDataType: - *mut *const ::std::os::raw::c_char, - pzCollSeq: - *mut *const ::std::os::raw::c_char, - pNotNull: *mut ::std::os::raw::c_int, - pPrimaryKey: - *mut ::std::os::raw::c_int, - pAutoinc: *mut ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_table_column_metadata( + db: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + zTableName: *const ::std::os::raw::c_char, + zColumnName: *const ::std::os::raw::c_char, + pzDataType: *mut *const ::std::os::raw::c_char, + pzCollSeq: *mut *const ::std::os::raw::c_char, + pNotNull: *mut ::std::os::raw::c_int, + pPrimaryKey: *mut ::std::os::raw::c_int, + pAutoinc: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_load_extension(db: *mut sqlite3, - zFile: *const ::std::os::raw::c_char, - zProc: *const ::std::os::raw::c_char, - pzErrMsg: *mut *mut ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_load_extension( + db: *mut sqlite3, + zFile: *const ::std::os::raw::c_char, + zProc: *const ::std::os::raw::c_char, + pzErrMsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_enable_load_extension(db: *mut sqlite3, - onoff: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_enable_load_extension( + db: *mut sqlite3, + onoff: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_auto_extension(xEntryPoint: - ::std::option::Option) - -> ::std::os::raw::c_int; + pub fn sqlite3_auto_extension( + xEntryPoint: ::std::option::Option, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_reset_auto_extension(); } #[repr(C)] -#[derive(Debug, Copy)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, } #[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!(::std::mem::size_of::() , 24usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_vtab { - fn clone(&self) -> Self { *self } +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 160usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_index_info { pub nConstraint: ::std::os::raw::c_int, pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, @@ -1391,7 +2129,7 @@ pub struct sqlite3_index_info { pub estimatedCost: f64, } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_index_info_sqlite3_index_constraint { pub iColumn: ::std::os::raw::c_int, pub op: ::std::os::raw::c_uchar, @@ -1400,275 +2138,458 @@ pub struct sqlite3_index_info_sqlite3_index_constraint { } #[test] fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!(::std::mem::size_of::() - , 12usize); - assert_eq!(::std::mem::align_of::() - , 4usize); -} -impl Clone for sqlite3_index_info_sqlite3_index_constraint { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_index_info_sqlite3_index_orderby { pub iColumn: ::std::os::raw::c_int, pub desc: ::std::os::raw::c_uchar, } #[test] fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!(::std::mem::size_of::() - , 8usize); - assert_eq!(::std::mem::align_of::() - , 4usize); -} -impl Clone for sqlite3_index_info_sqlite3_index_orderby { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_index_info_sqlite3_index_constraint_usage { pub argvIndex: ::std::os::raw::c_int, pub omit: ::std::os::raw::c_uchar, } #[test] fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!(::std::mem::size_of::() - , 8usize); - assert_eq!(::std::mem::align_of::() - , 4usize); -} -impl Clone for sqlite3_index_info_sqlite3_index_constraint_usage { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); } #[test] fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!(::std::mem::size_of::() , 72usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_index_info { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); +} +extern "C" { + pub fn sqlite3_create_module( + db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + arg1: *const sqlite3_module, + arg2: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_module_v2( + db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + arg1: *const sqlite3_module, + arg2: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy)] -pub struct sqlite3_vtab_cursor { - pub pVtab: *mut sqlite3_vtab, +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, } #[test] -fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!(::std::mem::size_of::() , 8usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_vtab_cursor { - fn clone(&self) -> Self { *self } +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option ::std::os::raw::c_int>, - pub xConnect: ::std::option::Option ::std::os::raw::c_int>, - pub xBestIndex: ::std::option::Option ::std::os::raw::c_int>, - pub xDisconnect: ::std::option::Option ::std::os::raw::c_int>, - pub xDestroy: ::std::option::Option ::std::os::raw::c_int>, - pub xOpen: ::std::option::Option ::std::os::raw::c_int>, - pub xClose: ::std::option::Option ::std::os::raw::c_int>, - pub xFilter: ::std::option::Option ::std::os::raw::c_int>, - pub xNext: ::std::option::Option ::std::os::raw::c_int>, - pub xEof: ::std::option::Option ::std::os::raw::c_int>, - pub xColumn: ::std::option::Option ::std::os::raw::c_int>, - pub xRowid: ::std::option::Option ::std::os::raw::c_int>, - pub xUpdate: ::std::option::Option ::std::os::raw::c_int>, - pub xBegin: ::std::option::Option ::std::os::raw::c_int>, - pub xSync: ::std::option::Option ::std::os::raw::c_int>, - pub xCommit: ::std::option::Option ::std::os::raw::c_int>, - pub xRollback: ::std::option::Option ::std::os::raw::c_int>, - pub xFindFunction: ::std::option::Option, - ppArg: - *mut *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int>, - pub xRename: ::std::option::Option ::std::os::raw::c_int>, +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, } #[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!(::std::mem::size_of::() , 160usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_module { - fn clone(&self) -> Self { *self } -} -extern "C" { - pub fn sqlite3_create_module(db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - arg1: *const sqlite3_module, - arg2: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_module_v2(db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - arg1: *const sqlite3_module, - arg2: *mut ::std::os::raw::c_void, - xDestroy: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_declare_vtab(arg1: *mut sqlite3, - zCreateTable: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_overload_function(arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +extern "C" { + pub fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + zCreateTable: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob([u8; 0]); +pub struct sqlite3_blob { + _unused: [u8; 0], +} extern "C" { - pub fn sqlite3_blob_open(arg1: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - zTable: *const ::std::os::raw::c_char, - zColumn: *const ::std::os::raw::c_char, - iRow: sqlite3_int64, - flags: ::std::os::raw::c_int, - ppBlob: *mut *mut sqlite3_blob) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_open( + arg1: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + zTable: *const ::std::os::raw::c_char, + zColumn: *const ::std::os::raw::c_char, + iRow: sqlite3_int64, + flags: ::std::os::raw::c_int, + ppBlob: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_read(arg1: *mut sqlite3_blob, - Z: *mut ::std::os::raw::c_void, - N: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + Z: *mut ::std::os::raw::c_void, + N: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_write(arg1: *mut sqlite3_blob, - z: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + z: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) - -> *mut sqlite3_vfs; + pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs; } extern "C" { - pub fn sqlite3_vfs_register(arg1: *mut sqlite3_vfs, - makeDflt: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + makeDflt: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) - -> ::std::os::raw::c_int; + pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) - -> *mut sqlite3_mutex; + pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex; } extern "C" { pub fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex); @@ -1677,159 +2598,435 @@ extern "C" { pub fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex); } extern "C" { - pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) - -> ::std::os::raw::c_int; + pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option *mut sqlite3_mutex>, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexNotheld: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, } #[test] fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!(::std::mem::size_of::() , 72usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_mutex_methods { - fn clone(&self) -> Self { *self } -} -extern "C" { - pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) - -> ::std::os::raw::c_int; + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +extern "C" { + pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex; } extern "C" { - pub fn sqlite3_file_control(arg1: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - op: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_file_control( + arg1: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + op: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) - -> ::std::os::raw::c_int; + pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_status(op: ::std::os::raw::c_int, - pCurrent: *mut ::std::os::raw::c_int, - pHighwater: *mut ::std::os::raw::c_int, - resetFlag: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_status( + op: ::std::os::raw::c_int, + pCurrent: *mut ::std::os::raw::c_int, + pHighwater: *mut ::std::os::raw::c_int, + resetFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_db_status(arg1: *mut sqlite3, op: ::std::os::raw::c_int, - pCur: *mut ::std::os::raw::c_int, - pHiwtr: *mut ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_db_status( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + pCur: *mut ::std::os::raw::c_int, + pHiwtr: *mut ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_stmt_status(arg1: *mut sqlite3_stmt, - op: ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_stmt_status( + arg1: *mut sqlite3_stmt, + op: ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache([u8; 0]); +pub struct sqlite3_pcache { + _unused: [u8; 0], +} #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_pcache_methods { pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option ::std::os::raw::c_int>, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option *mut sqlite3_pcache>, - pub xCachesize: ::std::option::Option, - pub xPagecount: ::std::option::Option ::std::os::raw::c_int>, - pub xFetch: ::std::option::Option *mut ::std::os::raw::c_void>, - pub xUnpin: ::std::option::Option, - pub xRekey: ::std::option::Option, - pub xTruncate: ::std::option::Option, - pub xDestroy: ::std::option::Option, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, } #[test] fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!(::std::mem::size_of::() , 88usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_pcache_methods { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); } +pub type __builtin_va_list = [__va_list_tag; 1usize]; #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct __va_list_tag { pub gp_offset: ::std::os::raw::c_uint, pub fp_offset: ::std::os::raw::c_uint, pub overflow_arg_area: *mut ::std::os::raw::c_void, pub reg_save_area: *mut ::std::os::raw::c_void, } -impl Clone for __va_list_tag { - fn clone(&self) -> Self { *self } +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); } -pub type __builtin_va_list = [__va_list_tag; 1usize]; - -pub const SQLITE_DETERMINISTIC: i32 = 2048; diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs index c482c77b9..39ee0a41b 100644 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs @@ -1,5 +1,6 @@ -/* automatically generated by rust-bindgen */ +/* automatically generated by rust-bindgen 0.57.0 */ +pub const __GNUC_VA_LIST: i32 = 1; pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.7.16\0"; pub const SQLITE_VERSION_NUMBER: i32 = 3007016; pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = @@ -285,8 +286,9 @@ pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; pub const SQLITE_ROLLBACK: i32 = 1; pub const SQLITE_FAIL: i32 = 3; pub const SQLITE_REPLACE: i32 = 5; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; extern "C" { - #[link_name = "\u{1}sqlite3_version"] pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; } #[repr(C)] @@ -1111,11 +1113,9 @@ pub struct sqlite3_context { pub type sqlite3_destructor_type = ::std::option::Option; extern "C" { - #[link_name = "\u{1}sqlite3_temp_directory"] pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; } extern "C" { - #[link_name = "\u{1}sqlite3_data_directory"] pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; } #[repr(C)] @@ -3222,6 +3222,12 @@ pub struct sqlite3_api_routines { pub value_type: ::std::option::Option< unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, >, + pub vmprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, pub overload_function: ::std::option::Option< unsafe extern "C" fn( arg1: *mut sqlite3, @@ -3604,6 +3610,14 @@ pub struct sqlite3_api_routines { arg2: *const ::std::os::raw::c_char, ) -> *const ::std::os::raw::c_char, >, + pub vsnprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, pub wal_checkpoint_v2: ::std::option::Option< unsafe extern "C" fn( arg1: *mut sqlite3, @@ -3618,7 +3632,7 @@ pub struct sqlite3_api_routines { fn bindgen_test_layout_sqlite3_api_routines() { assert_eq!( ::std::mem::size_of::(), - 1520usize, + 1536usize, concat!("Size of: ", stringify!(sqlite3_api_routines)) ); assert_eq!( @@ -4919,6 +4933,16 @@ fn bindgen_test_layout_sqlite3_api_routines() { stringify!(value_type) ) ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, + 912usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vmprintf) + ) + ); assert_eq!( unsafe { &(*(::std::ptr::null::())).overload_function as *const _ as usize @@ -5766,6 +5790,16 @@ fn bindgen_test_layout_sqlite3_api_routines() { stringify!(uri_parameter) ) ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vsnprintf as *const _ as usize }, + 1520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vsnprintf) + ) + ); assert_eq!( unsafe { &(*(::std::ptr::null::())).wal_checkpoint_v2 as *const _ as usize @@ -5779,9 +5813,70 @@ fn bindgen_test_layout_sqlite3_api_routines() { ) ); } +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} // sqlite3_api is defined in lib.rs as either a static or an extern when compiled as a loadable_extension -#[cfg(feature = "loadable_extension")] use crate::sqlite3_api; // sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) @@ -6782,10 +6877,7 @@ pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw )))(arg1) } -pub unsafe fn sqlite3_mprintf( - arg1: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { +pub unsafe fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char { if sqlite3_api.is_null() { panic!("sqlite3_api is null"); } @@ -6793,7 +6885,7 @@ pub unsafe fn sqlite3_mprintf( "sqlite3_api contains null pointer for ", "mprintf", " function" - )))(arg1, vararg1) + )))(arg1) } pub unsafe fn sqlite3_open( @@ -7146,7 +7238,6 @@ pub unsafe fn sqlite3_snprintf( arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_char, arg3: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, ) -> *mut ::std::os::raw::c_char { if sqlite3_api.is_null() { panic!("sqlite3_api is null"); @@ -7155,7 +7246,7 @@ pub unsafe fn sqlite3_snprintf( "sqlite3_api contains null pointer for ", "snprintf", " function" - )))(arg1, arg2, arg3, vararg1) + )))(arg1, arg2, arg3) } pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { @@ -7412,6 +7503,20 @@ pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_ )))(arg1) } +pub unsafe fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vmprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vmprintf", + " function" + )))(arg1, arg2) +} + pub unsafe fn sqlite3_overload_function( arg1: *mut sqlite3, zFuncName: *const ::std::os::raw::c_char, @@ -7836,10 +7941,7 @@ pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std: )))(arg1, arg2) } -pub unsafe fn sqlite3_test_control( - arg1: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { +pub unsafe fn sqlite3_test_control(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { if sqlite3_api.is_null() { panic!("sqlite3_api is null"); } @@ -7847,7 +7949,7 @@ pub unsafe fn sqlite3_test_control( "sqlite3_api contains null pointer for ", "test_control", " function" - )))(arg1, vararg1) + )))(arg1) } pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { @@ -8064,8 +8166,37 @@ pub unsafe fn sqlite3_create_function_v2( pub unsafe fn sqlite3_db_config( arg1: *mut sqlite3, arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_config", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_db_config_constchar( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + vararg1: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_config", + " function" + )))(arg1, arg2, vararg1) +} + +pub unsafe fn sqlite3_db_config_int_mutint( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, vararg1: ::std::os::raw::c_int, - vararg2: &mut i32, + vararg2: *mut ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { if sqlite3_api.is_null() { panic!("sqlite3_api is null"); @@ -8077,6 +8208,23 @@ pub unsafe fn sqlite3_db_config( )))(arg1, arg2, vararg1, vararg2) } +pub unsafe fn sqlite3_db_config_void_int_mutint( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + vararg1: *mut ::core::ffi::c_void, + vararg2: ::std::os::raw::c_int, + vararg3: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_config", + " function" + )))(arg1, arg2, vararg1, vararg2, vararg3) +} + pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { if sqlite3_api.is_null() { panic!("sqlite3_api is null"); @@ -8116,11 +8264,7 @@ pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_ )))(arg1) } -pub unsafe fn sqlite3_log( - arg1: ::std::os::raw::c_int, - arg2: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) { +pub unsafe fn sqlite3_log(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char) { if sqlite3_api.is_null() { panic!("sqlite3_api is null"); } @@ -8128,7 +8272,7 @@ pub unsafe fn sqlite3_log( "sqlite3_api contains null pointer for ", "log", " function" - )))(arg1, arg2, vararg1) + )))(arg1, arg2) } pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { @@ -8267,6 +8411,20 @@ pub unsafe fn sqlite3_blob_reopen( pub unsafe fn sqlite3_vtab_config( arg1: *mut sqlite3, op: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_config", + " function" + )))(arg1, op) +} + +pub unsafe fn sqlite3_vtab_config_int( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, vararg1: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { if sqlite3_api.is_null() { @@ -8431,6 +8589,22 @@ pub unsafe fn sqlite3_uri_parameter( )))(arg1, arg2) } +pub unsafe fn sqlite3_vsnprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vsnprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vsnprintf", + " function" + )))(arg1, arg2, arg3, arg4) +} + pub unsafe fn sqlite3_wal_checkpoint_v2( arg1: *mut sqlite3, arg2: *const ::std::os::raw::c_char, @@ -8447,5 +8621,3 @@ pub unsafe fn sqlite3_wal_checkpoint_v2( " function" )))(arg1, arg2, arg3, arg4, arg5) } - -pub const SQLITE_DETERMINISTIC: i32 = 2048; diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16.rs index cd1489511..913de8710 100644 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16.rs +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16.rs @@ -1,10 +1,10 @@ -/* automatically generated by rust-bindgen */ +/* automatically generated by rust-bindgen 0.57.0 */ pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.7.16\x00"; +pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.7.16\0"; pub const SQLITE_VERSION_NUMBER: i32 = 3007016; pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = - b"2013-03-18 11:39:23 66d5f2b76750f3520eb7a495f6247206758f5b90\x00"; + b"2013-03-18 11:39:23 66d5f2b76750f3520eb7a495f6247206758f5b90\0"; pub const SQLITE_OK: i32 = 0; pub const SQLITE_ERROR: i32 = 1; pub const SQLITE_INTERNAL: i32 = 2; @@ -289,7 +289,6 @@ pub const SQLITE_REPLACE: i32 = 5; pub type va_list = __builtin_va_list; pub type __gnuc_va_list = __builtin_va_list; extern "C" { - #[link_name = "sqlite3_version"] pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; } extern "C" { @@ -302,19 +301,21 @@ extern "C" { pub fn sqlite3_libversion_number() -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_compileoption_used(zOptName: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_compileoption_used( + zOptName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_compileoption_get(N: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_compileoption_get(N: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; } extern "C" { pub fn sqlite3_threadsafe() -> ::std::os::raw::c_int; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3([u8; 0]); +pub struct sqlite3 { + _unused: [u8; 0], +} pub type sqlite_int64 = ::std::os::raw::c_longlong; pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; pub type sqlite3_int64 = sqlite_int64; @@ -325,160 +326,348 @@ extern "C" { extern "C" { pub fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int; } -pub type sqlite3_callback = - ::std::option::Option ::std::os::raw::c_int>; -extern "C" { - pub fn sqlite3_exec(arg1: *mut sqlite3, - sql: *const ::std::os::raw::c_char, - callback: - ::std::option::Option - ::std::os::raw::c_int>, - arg2: *mut ::std::os::raw::c_void, - errmsg: *mut *mut ::std::os::raw::c_char) - -> ::std::os::raw::c_int; +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +extern "C" { + pub fn sqlite3_exec( + arg1: *mut sqlite3, + sql: *const ::std::os::raw::c_char, + callback: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg2: *mut ::std::os::raw::c_void, + errmsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_file { - pub pMethods: *const sqlite3_file_sqlite3_io_methods, -} -#[repr(C)] -#[derive(Debug, Copy)] -pub struct sqlite3_file_sqlite3_io_methods { - pub iVersion: ::std::os::raw::c_int, - pub xClose: ::std::option::Option ::std::os::raw::c_int>, - pub xRead: ::std::option::Option ::std::os::raw::c_int>, - pub xWrite: ::std::option::Option ::std::os::raw::c_int>, - pub xTruncate: ::std::option::Option ::std::os::raw::c_int>, - pub xSync: ::std::option::Option ::std::os::raw::c_int>, - pub xFileSize: ::std::option::Option ::std::os::raw::c_int>, - pub xLock: ::std::option::Option ::std::os::raw::c_int>, - pub xUnlock: ::std::option::Option ::std::os::raw::c_int>, - pub xCheckReservedLock: ::std::option::Option - ::std::os::raw::c_int>, - pub xFileControl: ::std::option::Option ::std::os::raw::c_int>, - pub xSectorSize: ::std::option::Option ::std::os::raw::c_int>, - pub xDeviceCharacteristics: ::std::option::Option - ::std::os::raw::c_int>, - pub xShmMap: ::std::option::Option ::std::os::raw::c_int>, - pub xShmLock: ::std::option::Option ::std::os::raw::c_int>, - pub xShmBarrier: ::std::option::Option, - pub xShmUnmap: ::std::option::Option ::std::os::raw::c_int>, + pub pMethods: *const sqlite3_io_methods, } #[test] -fn bindgen_test_layout_sqlite3_file_sqlite3_io_methods() { - assert_eq!(::std::mem::size_of::() , - 136usize); - assert_eq!(::std::mem::align_of::() , - 8usize); +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); } -impl Clone for sqlite3_file_sqlite3_io_methods { - fn clone(&self) -> Self { *self } +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xShmMap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iPg: ::std::os::raw::c_int, + pgsz: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xShmLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + offset: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xShmBarrier: ::std::option::Option, + pub xShmUnmap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + deleteFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, } #[test] -fn bindgen_test_layout_sqlite3_file() { - assert_eq!(::std::mem::size_of::() , 8usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_file { - fn clone(&self) -> Self { *self } +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 136usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmMap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmBarrier) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmUnmap) + ) + ); } -pub type sqlite3_io_methods = sqlite3_file_sqlite3_io_methods; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_mutex([u8; 0]); +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +pub type sqlite3_syscall_ptr = ::std::option::Option; #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_vfs { pub iVersion: ::std::os::raw::c_int, pub szOsFile: ::std::os::raw::c_int, @@ -486,124 +675,349 @@ pub struct sqlite3_vfs { pub pNext: *mut sqlite3_vfs, pub zName: *const ::std::os::raw::c_char, pub pAppData: *mut ::std::os::raw::c_void, - pub xOpen: ::std::option::Option ::std::os::raw::c_int>, - pub xDelete: ::std::option::Option ::std::os::raw::c_int>, - pub xAccess: ::std::option::Option ::std::os::raw::c_int>, - pub xFullPathname: ::std::option::Option ::std::os::raw::c_int>, - pub xDlOpen: ::std::option::Option *mut ::std::os::raw::c_void>, - pub xDlError: ::std::option::Option, - pub xDlSym: ::std::option::Option - ::std::option::Option>, - pub xDlClose: ::std::option::Option, - pub xRandomness: ::std::option::Option ::std::os::raw::c_int>, - pub xSleep: ::std::option::Option ::std::os::raw::c_int>, - pub xCurrentTime: ::std::option::Option ::std::os::raw::c_int>, - pub xGetLastError: ::std::option::Option ::std::os::raw::c_int>, - pub xCurrentTimeInt64: ::std::option::Option - ::std::os::raw::c_int>, - pub xSetSystemCall: ::std::option::Option ::std::os::raw::c_int>, - pub xGetSystemCall: ::std::option::Option - ::std::option::Option>, - pub xNextSystemCall: ::std::option::Option - *const ::std::os::raw::c_char>, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTimeInt64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xSetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: sqlite3_syscall_ptr, + ) -> ::std::os::raw::c_int, + >, + pub xGetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> sqlite3_syscall_ptr, + >, + pub xNextSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, } #[test] fn bindgen_test_layout_sqlite3_vfs() { - assert_eq!(::std::mem::size_of::() , 168usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_vfs { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 168usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTimeInt64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xNextSystemCall) + ) + ); } -pub type sqlite3_syscall_ptr = ::std::option::Option; extern "C" { pub fn sqlite3_initialize() -> ::std::os::raw::c_int; } @@ -617,52 +1031,138 @@ extern "C" { pub fn sqlite3_os_end() -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) - -> ::std::os::raw::c_int; + pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_db_config(arg1: *mut sqlite3, - op: ::std::os::raw::c_int, ...) - -> ::std::os::raw::c_int; + pub fn sqlite3_db_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_mem_methods { - pub xMalloc: ::std::option::Option *mut ::std::os::raw::c_void>, - pub xFree: ::std::option::Option, - pub xRealloc: ::std::option::Option *mut ::std::os::raw::c_void>, - pub xSize: ::std::option::Option ::std::os::raw::c_int>, - pub xRoundup: ::std::option::Option ::std::os::raw::c_int>, - pub xInit: ::std::option::Option ::std::os::raw::c_int>, - pub xShutdown: ::std::option::Option, + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, pub pAppData: *mut ::std::os::raw::c_void, } #[test] fn bindgen_test_layout_sqlite3_mem_methods() { - assert_eq!(::std::mem::size_of::() , 64usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_mem_methods { - fn clone(&self) -> Self { *self } -} -extern "C" { - pub fn sqlite3_extended_result_codes(arg1: *mut sqlite3, - onoff: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +extern "C" { + pub fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + onoff: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite3_int64; @@ -677,71 +1177,76 @@ extern "C" { pub fn sqlite3_interrupt(arg1: *mut sqlite3); } extern "C" { - pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_busy_handler(arg1: *mut sqlite3, - arg2: - ::std::option::Option - ::std::os::raw::c_int>, - arg3: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_busy_timeout(arg1: *mut sqlite3, ms: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_get_table(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - pazResult: *mut *mut *mut ::std::os::raw::c_char, - pnRow: *mut ::std::os::raw::c_int, - pnColumn: *mut ::std::os::raw::c_int, - pzErrmsg: *mut *mut ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_get_table( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + pazResult: *mut *mut *mut ::std::os::raw::c_char, + pnRow: *mut ::std::os::raw::c_int, + pnColumn: *mut ::std::os::raw::c_int, + pzErrmsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char); } extern "C" { pub fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char, ...) - -> *mut ::std::os::raw::c_char; + -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_vmprintf(arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag) - -> *mut ::std::os::raw::c_char; + pub fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_snprintf(arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, ...) - -> *mut ::std::os::raw::c_char; + pub fn sqlite3_snprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_vsnprintf(arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut __va_list_tag) - -> *mut ::std::os::raw::c_char; + pub fn sqlite3_vsnprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_realloc(arg1: *mut ::std::os::raw::c_void, - arg2: ::std::os::raw::c_int) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; } extern "C" { pub fn sqlite3_free(arg1: *mut ::std::os::raw::c_void); @@ -750,463 +1255,487 @@ extern "C" { pub fn sqlite3_memory_used() -> sqlite3_int64; } extern "C" { - pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) - -> sqlite3_int64; + pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) -> sqlite3_int64; } extern "C" { - pub fn sqlite3_randomness(N: ::std::os::raw::c_int, - P: *mut ::std::os::raw::c_void); + pub fn sqlite3_randomness(N: ::std::os::raw::c_int, P: *mut ::std::os::raw::c_void); } extern "C" { - pub fn sqlite3_set_authorizer(arg1: *mut sqlite3, - xAuth: - ::std::option::Option - ::std::os::raw::c_int>, - pUserData: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + xAuth: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pUserData: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_trace(arg1: *mut sqlite3, - xTrace: - ::std::option::Option, - arg2: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_profile(arg1: *mut sqlite3, - xProfile: - ::std::option::Option, - arg2: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_profile( + arg1: *mut sqlite3, + xProfile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_progress_handler(arg1: *mut sqlite3, - arg2: ::std::os::raw::c_int, - arg3: - ::std::option::Option - ::std::os::raw::c_int>, - arg4: *mut ::std::os::raw::c_void); + pub fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ); } extern "C" { - pub fn sqlite3_open(filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3) -> ::std::os::raw::c_int; + pub fn sqlite3_open( + filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_open16(filename: *const ::std::os::raw::c_void, - ppDb: *mut *mut sqlite3) -> ::std::os::raw::c_int; + pub fn sqlite3_open16( + filename: *const ::std::os::raw::c_void, + ppDb: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_open_v2(filename: *const ::std::os::raw::c_char, - ppDb: *mut *mut sqlite3, - flags: ::std::os::raw::c_int, - zVfs: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_open_v2( + filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3, + flags: ::std::os::raw::c_int, + zVfs: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_uri_parameter(zFilename: *const ::std::os::raw::c_char, - zParam: *const ::std::os::raw::c_char) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_uri_parameter( + zFilename: *const ::std::os::raw::c_char, + zParam: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_uri_boolean(zFile: *const ::std::os::raw::c_char, - zParam: *const ::std::os::raw::c_char, - bDefault: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_uri_boolean( + zFile: *const ::std::os::raw::c_char, + zParam: *const ::std::os::raw::c_char, + bDefault: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_uri_int64(arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: sqlite3_int64) -> sqlite3_int64; + pub fn sqlite3_uri_int64( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_int64, + ) -> sqlite3_int64; } extern "C" { pub fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_extended_errcode(db: *mut sqlite3) - -> ::std::os::raw::c_int; + pub fn sqlite3_extended_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_errmsg(arg1: *mut sqlite3) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_errmsg16(arg1: *mut sqlite3) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_errstr(arg1: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_stmt([u8; 0]); +pub struct sqlite3_stmt { + _unused: [u8; 0], +} extern "C" { - pub fn sqlite3_limit(arg1: *mut sqlite3, id: ::std::os::raw::c_int, - newVal: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_limit( + arg1: *mut sqlite3, + id: ::std::os::raw::c_int, + newVal: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_prepare( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare_v2(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_char, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_prepare_v2( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare16(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_prepare16( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_prepare16_v2(db: *mut sqlite3, - zSql: *const ::std::os::raw::c_void, - nByte: ::std::os::raw::c_int, - ppStmt: *mut *mut sqlite3_stmt, - pzTail: *mut *const ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_prepare16_v2( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_stmt_readonly(pStmt: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_stmt_readonly(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct Mem([u8; 0]); +pub struct Mem { + _unused: [u8; 0], +} pub type sqlite3_value = Mem; #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_context([u8; 0]); +pub struct sqlite3_context { + _unused: [u8; 0], +} extern "C" { - pub fn sqlite3_bind_blob(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - arg4: - ::std::option::Option) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_double(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, arg3: f64) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_int(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_int64(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: sqlite3_int64) -> ::std::os::raw::c_int; + pub fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_int64, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_null(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_text(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_char, - n: ::std::os::raw::c_int, - arg4: - ::std::option::Option) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_text16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const ::std::os::raw::c_void, - arg4: ::std::os::raw::c_int, - arg5: - ::std::option::Option) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_value(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - arg3: *const sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_zeroblob(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int, - n: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_bind_parameter_name(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_bind_parameter_index(arg1: *mut sqlite3_stmt, - zName: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_name(arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_name16(arg1: *mut sqlite3_stmt, - N: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_database_name(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_database_name16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_table_name(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_table_name16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_origin_name(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_origin_name16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_decltype(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_column_decltype16(arg1: *mut sqlite3_stmt, - arg2: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { pub fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_blob(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_bytes(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_bytes16(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) -> f64; + pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64; } extern "C" { - pub fn sqlite3_column_int(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_int64(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) -> sqlite3_int64; + pub fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> sqlite3_int64; } extern "C" { - pub fn sqlite3_column_text(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_uchar; + pub fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar; } extern "C" { - pub fn sqlite3_column_text16(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_column_type(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_column_value(arg1: *mut sqlite3_stmt, - iCol: ::std::os::raw::c_int) - -> *mut sqlite3_value; + pub fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value; } extern "C" { - pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_create_function(db: *mut sqlite3, - zFunctionName: - *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: - ::std::option::Option, - xStep: - ::std::option::Option, - xFinal: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function16(db: *mut sqlite3, - zFunctionName: - *const ::std::os::raw::c_void, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: - ::std::option::Option, - xStep: - ::std::option::Option, - xFinal: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_function_v2(db: *mut sqlite3, - zFunctionName: - *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int, - eTextRep: ::std::os::raw::c_int, - pApp: *mut ::std::os::raw::c_void, - xFunc: - ::std::option::Option, - xStep: - ::std::option::Option, - xFinal: - ::std::option::Option, - xDestroy: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) - -> ::std::os::raw::c_int; + pub fn sqlite3_create_function( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function16( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_void, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function_v2( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_transfer_bindings(arg1: *mut sqlite3_stmt, - arg2: *mut sqlite3_stmt) - -> ::std::os::raw::c_int; + pub fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_global_recover() -> ::std::os::raw::c_int; @@ -1215,111 +1744,106 @@ extern "C" { pub fn sqlite3_thread_cleanup(); } extern "C" { - pub fn sqlite3_memory_alarm(arg1: - ::std::option::Option, - arg2: *mut ::std::os::raw::c_void, - arg3: sqlite3_int64) -> ::std::os::raw::c_int; + pub fn sqlite3_memory_alarm( + arg1: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_int64, + arg3: ::std::os::raw::c_int, + ), + >, + arg2: *mut ::std::os::raw::c_void, + arg3: sqlite3_int64, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64; } extern "C" { - pub fn sqlite3_value_int(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite3_int64; } extern "C" { - pub fn sqlite3_value_text(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_uchar; + pub fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar; } extern "C" { - pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) - -> *const ::std::os::raw::c_void; + pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_value_type(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) - -> ::std::os::raw::c_int; + pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_aggregate_context(arg1: *mut sqlite3_context, - nBytes: ::std::os::raw::c_int) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_user_data(arg1: *mut sqlite3_context) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) - -> *mut sqlite3; + pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3; } extern "C" { - pub fn sqlite3_get_auxdata(arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_set_auxdata(arg1: *mut sqlite3_context, - N: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void, - arg3: - ::std::option::Option); + pub fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option, + ); } pub type sqlite3_destructor_type = - ::std::option::Option; + ::std::option::Option; extern "C" { - pub fn sqlite3_result_blob(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); + pub fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); } extern "C" { pub fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64); } extern "C" { - pub fn sqlite3_result_error(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int); + pub fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ); } extern "C" { - pub fn sqlite3_result_error16(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int); + pub fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ); } extern "C" { pub fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context); @@ -1328,229 +1852,204 @@ extern "C" { pub fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context); } extern "C" { - pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int); + pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_result_int(arg1: *mut sqlite3_context, - arg2: ::std::os::raw::c_int); + pub fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, - arg2: sqlite3_int64); + pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite3_int64); } extern "C" { pub fn sqlite3_result_null(arg1: *mut sqlite3_context); } extern "C" { - pub fn sqlite3_result_text(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); -} -extern "C" { - pub fn sqlite3_result_text16(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); -} -extern "C" { - pub fn sqlite3_result_text16le(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); -} -extern "C" { - pub fn sqlite3_result_text16be(arg1: *mut sqlite3_context, - arg2: *const ::std::os::raw::c_void, - arg3: ::std::os::raw::c_int, - arg4: - ::std::option::Option); -} -extern "C" { - pub fn sqlite3_result_value(arg1: *mut sqlite3_context, - arg2: *mut sqlite3_value); -} -extern "C" { - pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, - n: ::std::os::raw::c_int); -} -extern "C" { - pub fn sqlite3_create_collation(arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - xCompare: - ::std::option::Option - ::std::os::raw::c_int>) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation_v2(arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - eTextRep: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - xCompare: - ::std::option::Option - ::std::os::raw::c_int>, - xDestroy: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_collation16(arg1: *mut sqlite3, - zName: *const ::std::os::raw::c_void, - eTextRep: ::std::os::raw::c_int, - pArg: *mut ::std::os::raw::c_void, - xCompare: - ::std::option::Option - ::std::os::raw::c_int>) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed(arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_collation_needed16(arg1: *mut sqlite3, - arg2: *mut ::std::os::raw::c_void, - arg3: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; -} -extern "C" { - #[link_name = "sqlite3_temp_directory"] + pub fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value); +} +extern "C" { + pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, n: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_create_collation( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation16( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_void, + eTextRep: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; } extern "C" { - #[link_name = "sqlite3_data_directory"] pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) - -> ::std::os::raw::c_int; + pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3; } extern "C" { - pub fn sqlite3_db_filename(db: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char) - -> *const ::std::os::raw::c_char; + pub fn sqlite3_db_filename( + db: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char; } extern "C" { - pub fn sqlite3_db_readonly(db: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_db_readonly( + db: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) - -> *mut sqlite3_stmt; + pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) -> *mut sqlite3_stmt; } extern "C" { - pub fn sqlite3_commit_hook(arg1: *mut sqlite3, - arg2: - ::std::option::Option - ::std::os::raw::c_int>, - arg3: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_rollback_hook(arg1: *mut sqlite3, - arg2: - ::std::option::Option, - arg3: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_update_hook(arg1: *mut sqlite3, - arg2: - ::std::option::Option, - arg3: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_db_release_memory(arg1: *mut sqlite3) - -> ::std::os::raw::c_int; + pub fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_soft_heap_limit64(N: sqlite3_int64) -> sqlite3_int64; @@ -1559,60 +2058,418 @@ extern "C" { pub fn sqlite3_soft_heap_limit(N: ::std::os::raw::c_int); } extern "C" { - pub fn sqlite3_table_column_metadata(db: *mut sqlite3, - zDbName: - *const ::std::os::raw::c_char, - zTableName: - *const ::std::os::raw::c_char, - zColumnName: - *const ::std::os::raw::c_char, - pzDataType: - *mut *const ::std::os::raw::c_char, - pzCollSeq: - *mut *const ::std::os::raw::c_char, - pNotNull: *mut ::std::os::raw::c_int, - pPrimaryKey: - *mut ::std::os::raw::c_int, - pAutoinc: *mut ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_table_column_metadata( + db: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + zTableName: *const ::std::os::raw::c_char, + zColumnName: *const ::std::os::raw::c_char, + pzDataType: *mut *const ::std::os::raw::c_char, + pzCollSeq: *mut *const ::std::os::raw::c_char, + pNotNull: *mut ::std::os::raw::c_int, + pPrimaryKey: *mut ::std::os::raw::c_int, + pAutoinc: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_load_extension(db: *mut sqlite3, - zFile: *const ::std::os::raw::c_char, - zProc: *const ::std::os::raw::c_char, - pzErrMsg: *mut *mut ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_load_extension( + db: *mut sqlite3, + zFile: *const ::std::os::raw::c_char, + zProc: *const ::std::os::raw::c_char, + pzErrMsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_enable_load_extension(db: *mut sqlite3, - onoff: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_enable_load_extension( + db: *mut sqlite3, + onoff: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_auto_extension(xEntryPoint: - ::std::option::Option) - -> ::std::os::raw::c_int; + pub fn sqlite3_auto_extension( + xEntryPoint: ::std::option::Option, + ) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_reset_auto_extension(); } #[repr(C)] -#[derive(Debug, Copy)] -pub struct sqlite3_vtab { - pub pModule: *const sqlite3_module, - pub nRef: ::std::os::raw::c_int, - pub zErrMsg: *mut ::std::os::raw::c_char, +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSavepoint: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRelease: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRollbackTo: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, } #[test] -fn bindgen_test_layout_sqlite3_vtab() { - assert_eq!(::std::mem::size_of::() , 24usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_vtab { - fn clone(&self) -> Self { *self } +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 184usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSavepoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRelease) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollbackTo) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_index_info { pub nConstraint: ::std::os::raw::c_int, pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, @@ -1626,7 +2483,7 @@ pub struct sqlite3_index_info { pub estimatedCost: f64, } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_index_info_sqlite3_index_constraint { pub iColumn: ::std::os::raw::c_int, pub op: ::std::os::raw::c_uchar, @@ -1635,294 +2492,464 @@ pub struct sqlite3_index_info_sqlite3_index_constraint { } #[test] fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { - assert_eq!(::std::mem::size_of::() - , 12usize); - assert_eq!(::std::mem::align_of::() - , 4usize); -} -impl Clone for sqlite3_index_info_sqlite3_index_constraint { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_index_info_sqlite3_index_orderby { pub iColumn: ::std::os::raw::c_int, pub desc: ::std::os::raw::c_uchar, } #[test] fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { - assert_eq!(::std::mem::size_of::() - , 8usize); - assert_eq!(::std::mem::align_of::() - , 4usize); -} -impl Clone for sqlite3_index_info_sqlite3_index_orderby { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_index_info_sqlite3_index_constraint_usage { pub argvIndex: ::std::os::raw::c_int, pub omit: ::std::os::raw::c_uchar, } #[test] fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { - assert_eq!(::std::mem::size_of::() - , 8usize); - assert_eq!(::std::mem::align_of::() - , 4usize); -} -impl Clone for sqlite3_index_info_sqlite3_index_constraint_usage { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); } #[test] fn bindgen_test_layout_sqlite3_index_info() { - assert_eq!(::std::mem::size_of::() , 72usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_index_info { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); +} +extern "C" { + pub fn sqlite3_create_module( + db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + p: *const sqlite3_module, + pClientData: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_module_v2( + db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + p: *const sqlite3_module, + pClientData: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy)] -pub struct sqlite3_vtab_cursor { - pub pVtab: *mut sqlite3_vtab, +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, } #[test] -fn bindgen_test_layout_sqlite3_vtab_cursor() { - assert_eq!(::std::mem::size_of::() , 8usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_vtab_cursor { - fn clone(&self) -> Self { *self } +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] -pub struct sqlite3_module { - pub iVersion: ::std::os::raw::c_int, - pub xCreate: ::std::option::Option ::std::os::raw::c_int>, - pub xConnect: ::std::option::Option ::std::os::raw::c_int>, - pub xBestIndex: ::std::option::Option ::std::os::raw::c_int>, - pub xDisconnect: ::std::option::Option ::std::os::raw::c_int>, - pub xDestroy: ::std::option::Option ::std::os::raw::c_int>, - pub xOpen: ::std::option::Option ::std::os::raw::c_int>, - pub xClose: ::std::option::Option ::std::os::raw::c_int>, - pub xFilter: ::std::option::Option ::std::os::raw::c_int>, - pub xNext: ::std::option::Option ::std::os::raw::c_int>, - pub xEof: ::std::option::Option ::std::os::raw::c_int>, - pub xColumn: ::std::option::Option ::std::os::raw::c_int>, - pub xRowid: ::std::option::Option ::std::os::raw::c_int>, - pub xUpdate: ::std::option::Option ::std::os::raw::c_int>, - pub xBegin: ::std::option::Option ::std::os::raw::c_int>, - pub xSync: ::std::option::Option ::std::os::raw::c_int>, - pub xCommit: ::std::option::Option ::std::os::raw::c_int>, - pub xRollback: ::std::option::Option ::std::os::raw::c_int>, - pub xFindFunction: ::std::option::Option, - ppArg: - *mut *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int>, - pub xRename: ::std::option::Option ::std::os::raw::c_int>, - pub xSavepoint: ::std::option::Option ::std::os::raw::c_int>, - pub xRelease: ::std::option::Option ::std::os::raw::c_int>, - pub xRollbackTo: ::std::option::Option ::std::os::raw::c_int>, +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, } #[test] -fn bindgen_test_layout_sqlite3_module() { - assert_eq!(::std::mem::size_of::() , 184usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_module { - fn clone(&self) -> Self { *self } -} -extern "C" { - pub fn sqlite3_create_module(db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - p: *const sqlite3_module, - pClientData: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_create_module_v2(db: *mut sqlite3, - zName: *const ::std::os::raw::c_char, - p: *const sqlite3_module, - pClientData: *mut ::std::os::raw::c_void, - xDestroy: - ::std::option::Option) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_declare_vtab(arg1: *mut sqlite3, - zSQL: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_overload_function(arg1: *mut sqlite3, - zFuncName: *const ::std::os::raw::c_char, - nArg: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +extern "C" { + pub fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + zSQL: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_blob([u8; 0]); +pub struct sqlite3_blob { + _unused: [u8; 0], +} extern "C" { - pub fn sqlite3_blob_open(arg1: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - zTable: *const ::std::os::raw::c_char, - zColumn: *const ::std::os::raw::c_char, - iRow: sqlite3_int64, - flags: ::std::os::raw::c_int, - ppBlob: *mut *mut sqlite3_blob) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_open( + arg1: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + zTable: *const ::std::os::raw::c_char, + zColumn: *const ::std::os::raw::c_char, + iRow: sqlite3_int64, + flags: ::std::os::raw::c_int, + ppBlob: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_reopen(arg1: *mut sqlite3_blob, arg2: sqlite3_int64) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_reopen( + arg1: *mut sqlite3_blob, + arg2: sqlite3_int64, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_read(arg1: *mut sqlite3_blob, - Z: *mut ::std::os::raw::c_void, - N: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + Z: *mut ::std::os::raw::c_void, + N: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_blob_write(arg1: *mut sqlite3_blob, - z: *const ::std::os::raw::c_void, - n: ::std::os::raw::c_int, - iOffset: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + z: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) - -> *mut sqlite3_vfs; + pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs; } extern "C" { - pub fn sqlite3_vfs_register(arg1: *mut sqlite3_vfs, - makeDflt: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + makeDflt: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) - -> ::std::os::raw::c_int; + pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) - -> *mut sqlite3_mutex; + pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex; } extern "C" { pub fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex); @@ -1931,367 +2958,871 @@ extern "C" { pub fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex); } extern "C" { - pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) - -> ::std::os::raw::c_int; + pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_mutex_methods { - pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexAlloc: ::std::option::Option *mut sqlite3_mutex>, - pub xMutexFree: ::std::option::Option, - pub xMutexEnter: ::std::option::Option, - pub xMutexTry: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexLeave: ::std::option::Option, - pub xMutexHeld: ::std::option::Option ::std::os::raw::c_int>, - pub xMutexNotheld: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, } #[test] fn bindgen_test_layout_sqlite3_mutex_methods() { - assert_eq!(::std::mem::size_of::() , 72usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_mutex_methods { - fn clone(&self) -> Self { *self } -} -extern "C" { - pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) - -> ::std::os::raw::c_int; -} -extern "C" { - pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) - -> ::std::os::raw::c_int; + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +extern "C" { + pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; } extern "C" { pub fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex; } extern "C" { - pub fn sqlite3_file_control(arg1: *mut sqlite3, - zDbName: *const ::std::os::raw::c_char, - op: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_file_control( + arg1: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + op: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) - -> ::std::os::raw::c_int; + pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_status(op: ::std::os::raw::c_int, - pCurrent: *mut ::std::os::raw::c_int, - pHighwater: *mut ::std::os::raw::c_int, - resetFlag: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_status( + op: ::std::os::raw::c_int, + pCurrent: *mut ::std::os::raw::c_int, + pHighwater: *mut ::std::os::raw::c_int, + resetFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_db_status(arg1: *mut sqlite3, op: ::std::os::raw::c_int, - pCur: *mut ::std::os::raw::c_int, - pHiwtr: *mut ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_db_status( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + pCur: *mut ::std::os::raw::c_int, + pHiwtr: *mut ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_stmt_status(arg1: *mut sqlite3_stmt, - op: ::std::os::raw::c_int, - resetFlg: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_stmt_status( + arg1: *mut sqlite3_stmt, + op: ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_pcache([u8; 0]); +pub struct sqlite3_pcache { + _unused: [u8; 0], +} #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_pcache_page { pub pBuf: *mut ::std::os::raw::c_void, pub pExtra: *mut ::std::os::raw::c_void, } #[test] fn bindgen_test_layout_sqlite3_pcache_page() { - assert_eq!(::std::mem::size_of::() , 16usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_pcache_page { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_page)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pBuf as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pBuf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pExtra as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_page), + "::", + stringify!(pExtra) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_pcache_methods2 { pub iVersion: ::std::os::raw::c_int, pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option ::std::os::raw::c_int>, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option *mut sqlite3_pcache>, - pub xCachesize: ::std::option::Option, - pub xPagecount: ::std::option::Option ::std::os::raw::c_int>, - pub xFetch: ::std::option::Option *mut sqlite3_pcache_page>, - pub xUnpin: ::std::option::Option, - pub xRekey: ::std::option::Option, - pub xTruncate: ::std::option::Option, - pub xDestroy: ::std::option::Option, - pub xShrink: ::std::option::Option, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + szExtra: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache_page, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut sqlite3_pcache_page, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, + pub xShrink: ::std::option::Option, } #[test] fn bindgen_test_layout_sqlite3_pcache_methods2() { - assert_eq!(::std::mem::size_of::() , 104usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_pcache_methods2 { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 104usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods2)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iVersion as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDestroy as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShrink as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods2), + "::", + stringify!(xShrink) + ) + ); } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_pcache_methods { pub pArg: *mut ::std::os::raw::c_void, - pub xInit: ::std::option::Option ::std::os::raw::c_int>, - pub xShutdown: ::std::option::Option, - pub xCreate: ::std::option::Option *mut sqlite3_pcache>, - pub xCachesize: ::std::option::Option, - pub xPagecount: ::std::option::Option ::std::os::raw::c_int>, - pub xFetch: ::std::option::Option *mut ::std::os::raw::c_void>, - pub xUnpin: ::std::option::Option, - pub xRekey: ::std::option::Option, - pub xTruncate: ::std::option::Option, - pub xDestroy: ::std::option::Option, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, } #[test] fn bindgen_test_layout_sqlite3_pcache_methods() { - assert_eq!(::std::mem::size_of::() , 88usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_pcache_methods { - fn clone(&self) -> Self { *self } + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct sqlite3_backup([u8; 0]); +pub struct sqlite3_backup { + _unused: [u8; 0], +} extern "C" { - pub fn sqlite3_backup_init(pDest: *mut sqlite3, - zDestName: *const ::std::os::raw::c_char, - pSource: *mut sqlite3, - zSourceName: *const ::std::os::raw::c_char) - -> *mut sqlite3_backup; + pub fn sqlite3_backup_init( + pDest: *mut sqlite3, + zDestName: *const ::std::os::raw::c_char, + pSource: *mut sqlite3, + zSourceName: *const ::std::os::raw::c_char, + ) -> *mut sqlite3_backup; } extern "C" { - pub fn sqlite3_backup_step(p: *mut sqlite3_backup, - nPage: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_backup_step( + p: *mut sqlite3_backup, + nPage: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_backup_finish(p: *mut sqlite3_backup) - -> ::std::os::raw::c_int; + pub fn sqlite3_backup_finish(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_backup_remaining(p: *mut sqlite3_backup) - -> ::std::os::raw::c_int; + pub fn sqlite3_backup_remaining(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_backup_pagecount(p: *mut sqlite3_backup) - -> ::std::os::raw::c_int; + pub fn sqlite3_backup_pagecount(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_unlock_notify(pBlocked: *mut sqlite3, - xNotify: - ::std::option::Option, - pNotifyArg: *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + pub fn sqlite3_unlock_notify( + pBlocked: *mut sqlite3, + xNotify: ::std::option::Option< + unsafe extern "C" fn( + apArg: *mut *mut ::std::os::raw::c_void, + nArg: ::std::os::raw::c_int, + ), + >, + pNotifyArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_stricmp(arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_stricmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_strnicmp(arg1: *const ::std::os::raw::c_char, - arg2: *const ::std::os::raw::c_char, - arg3: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_strnicmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_log(iErrCode: ::std::os::raw::c_int, - zFormat: *const ::std::os::raw::c_char, ...); + pub fn sqlite3_log( + iErrCode: ::std::os::raw::c_int, + zFormat: *const ::std::os::raw::c_char, + ... + ); } extern "C" { - pub fn sqlite3_wal_hook(arg1: *mut sqlite3, - arg2: - ::std::option::Option - ::std::os::raw::c_int>, - arg3: *mut ::std::os::raw::c_void) - -> *mut ::std::os::raw::c_void; + pub fn sqlite3_wal_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; } extern "C" { - pub fn sqlite3_wal_autocheckpoint(db: *mut sqlite3, - N: ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_wal_autocheckpoint( + db: *mut sqlite3, + N: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_wal_checkpoint(db: *mut sqlite3, - zDb: *const ::std::os::raw::c_char) - -> ::std::os::raw::c_int; + pub fn sqlite3_wal_checkpoint( + db: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_wal_checkpoint_v2(db: *mut sqlite3, - zDb: *const ::std::os::raw::c_char, - eMode: ::std::os::raw::c_int, - pnLog: *mut ::std::os::raw::c_int, - pnCkpt: *mut ::std::os::raw::c_int) - -> ::std::os::raw::c_int; + pub fn sqlite3_wal_checkpoint_v2( + db: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + eMode: ::std::os::raw::c_int, + pnLog: *mut ::std::os::raw::c_int, + pnCkpt: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_vtab_config(arg1: *mut sqlite3, - op: ::std::os::raw::c_int, ...) - -> ::std::os::raw::c_int; + pub fn sqlite3_vtab_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int; } extern "C" { - pub fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) - -> ::std::os::raw::c_int; + pub fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_rtree_geometry_callback( + db: *mut sqlite3, + zGeom: *const ::std::os::raw::c_char, + xGeom: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_rtree_geometry, + n: ::std::os::raw::c_int, + a: *mut f64, + pRes: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pContext: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; } #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_rtree_geometry { pub pContext: *mut ::std::os::raw::c_void, pub nParam: ::std::os::raw::c_int, pub aParam: *mut f64, pub pUser: *mut ::std::os::raw::c_void, - pub xDelUser: ::std::option::Option, + pub xDelUser: ::std::option::Option, } #[test] fn bindgen_test_layout_sqlite3_rtree_geometry() { - assert_eq!(::std::mem::size_of::() , 40usize); - assert_eq!(::std::mem::align_of::() , 8usize); -} -impl Clone for sqlite3_rtree_geometry { - fn clone(&self) -> Self { *self } -} -extern "C" { - pub fn sqlite3_rtree_geometry_callback(db: *mut sqlite3, - zGeom: - *const ::std::os::raw::c_char, - xGeom: - ::std::option::Option - ::std::os::raw::c_int>, - pContext: - *mut ::std::os::raw::c_void) - -> ::std::os::raw::c_int; + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(xDelUser) + ) + ); } +pub type __builtin_va_list = [__va_list_tag; 1usize]; #[repr(C)] -#[derive(Debug, Copy)] +#[derive(Debug, Copy, Clone)] pub struct __va_list_tag { pub gp_offset: ::std::os::raw::c_uint, pub fp_offset: ::std::os::raw::c_uint, pub overflow_arg_area: *mut ::std::os::raw::c_void, pub reg_save_area: *mut ::std::os::raw::c_void, } -impl Clone for __va_list_tag { - fn clone(&self) -> Self { *self } +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); } -pub type __builtin_va_list = [__va_list_tag; 1usize]; - -pub const SQLITE_DETERMINISTIC: i32 = 2048; diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7-ext.rs new file mode 100644 index 000000000..6150cae8b --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7-ext.rs @@ -0,0 +1,7857 @@ +/* automatically generated by rust-bindgen 0.57.0 */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &'static [u8; 6usize] = b"3.7.7\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3007007; +pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = + b"2011-06-23 19:49:22 4374b7e83ea0a3fbc3691f9c0c936272862f32f2\0"; +pub const SQLITE_OK: i32 = 0; +pub const SQLITE_ERROR: i32 = 1; +pub const SQLITE_INTERNAL: i32 = 2; +pub const SQLITE_PERM: i32 = 3; +pub const SQLITE_ABORT: i32 = 4; +pub const SQLITE_BUSY: i32 = 5; +pub const SQLITE_LOCKED: i32 = 6; +pub const SQLITE_NOMEM: i32 = 7; +pub const SQLITE_READONLY: i32 = 8; +pub const SQLITE_INTERRUPT: i32 = 9; +pub const SQLITE_IOERR: i32 = 10; +pub const SQLITE_CORRUPT: i32 = 11; +pub const SQLITE_NOTFOUND: i32 = 12; +pub const SQLITE_FULL: i32 = 13; +pub const SQLITE_CANTOPEN: i32 = 14; +pub const SQLITE_PROTOCOL: i32 = 15; +pub const SQLITE_EMPTY: i32 = 16; +pub const SQLITE_SCHEMA: i32 = 17; +pub const SQLITE_TOOBIG: i32 = 18; +pub const SQLITE_CONSTRAINT: i32 = 19; +pub const SQLITE_MISMATCH: i32 = 20; +pub const SQLITE_MISUSE: i32 = 21; +pub const SQLITE_NOLFS: i32 = 22; +pub const SQLITE_AUTH: i32 = 23; +pub const SQLITE_FORMAT: i32 = 24; +pub const SQLITE_RANGE: i32 = 25; +pub const SQLITE_NOTADB: i32 = 26; +pub const SQLITE_ROW: i32 = 100; +pub const SQLITE_DONE: i32 = 101; +pub const SQLITE_IOERR_READ: i32 = 266; +pub const SQLITE_IOERR_SHORT_READ: i32 = 522; +pub const SQLITE_IOERR_WRITE: i32 = 778; +pub const SQLITE_IOERR_FSYNC: i32 = 1034; +pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; +pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; +pub const SQLITE_IOERR_FSTAT: i32 = 1802; +pub const SQLITE_IOERR_UNLOCK: i32 = 2058; +pub const SQLITE_IOERR_RDLOCK: i32 = 2314; +pub const SQLITE_IOERR_DELETE: i32 = 2570; +pub const SQLITE_IOERR_BLOCKED: i32 = 2826; +pub const SQLITE_IOERR_NOMEM: i32 = 3082; +pub const SQLITE_IOERR_ACCESS: i32 = 3338; +pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; +pub const SQLITE_IOERR_LOCK: i32 = 3850; +pub const SQLITE_IOERR_CLOSE: i32 = 4106; +pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; +pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; +pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; +pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; +pub const SQLITE_IOERR_SHMMAP: i32 = 5386; +pub const SQLITE_IOERR_SEEK: i32 = 5642; +pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; +pub const SQLITE_BUSY_RECOVERY: i32 = 261; +pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; +pub const SQLITE_CORRUPT_VTAB: i32 = 267; +pub const SQLITE_READONLY_RECOVERY: i32 = 264; +pub const SQLITE_READONLY_CANTLOCK: i32 = 520; +pub const SQLITE_OPEN_READONLY: i32 = 1; +pub const SQLITE_OPEN_READWRITE: i32 = 2; +pub const SQLITE_OPEN_CREATE: i32 = 4; +pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; +pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; +pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; +pub const SQLITE_OPEN_URI: i32 = 64; +pub const SQLITE_OPEN_MAIN_DB: i32 = 256; +pub const SQLITE_OPEN_TEMP_DB: i32 = 512; +pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; +pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; +pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; +pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; +pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; +pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; +pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; +pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; +pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; +pub const SQLITE_OPEN_WAL: i32 = 524288; +pub const SQLITE_IOCAP_ATOMIC: i32 = 1; +pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; +pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; +pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; +pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; +pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; +pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; +pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; +pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; +pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; +pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; +pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; +pub const SQLITE_LOCK_NONE: i32 = 0; +pub const SQLITE_LOCK_SHARED: i32 = 1; +pub const SQLITE_LOCK_RESERVED: i32 = 2; +pub const SQLITE_LOCK_PENDING: i32 = 3; +pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; +pub const SQLITE_SYNC_NORMAL: i32 = 2; +pub const SQLITE_SYNC_FULL: i32 = 3; +pub const SQLITE_SYNC_DATAONLY: i32 = 16; +pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; +pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_LAST_ERRNO: i32 = 4; +pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; +pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; +pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; +pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; +pub const SQLITE_ACCESS_EXISTS: i32 = 0; +pub const SQLITE_ACCESS_READWRITE: i32 = 1; +pub const SQLITE_ACCESS_READ: i32 = 2; +pub const SQLITE_SHM_UNLOCK: i32 = 1; +pub const SQLITE_SHM_LOCK: i32 = 2; +pub const SQLITE_SHM_SHARED: i32 = 4; +pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; +pub const SQLITE_SHM_NLOCK: i32 = 8; +pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; +pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; +pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; +pub const SQLITE_CONFIG_MALLOC: i32 = 4; +pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; +pub const SQLITE_CONFIG_SCRATCH: i32 = 6; +pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; +pub const SQLITE_CONFIG_HEAP: i32 = 8; +pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; +pub const SQLITE_CONFIG_MUTEX: i32 = 10; +pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; +pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; +pub const SQLITE_CONFIG_PCACHE: i32 = 14; +pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; +pub const SQLITE_CONFIG_LOG: i32 = 16; +pub const SQLITE_CONFIG_URI: i32 = 17; +pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; +pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; +pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; +pub const SQLITE_DENY: i32 = 1; +pub const SQLITE_IGNORE: i32 = 2; +pub const SQLITE_CREATE_INDEX: i32 = 1; +pub const SQLITE_CREATE_TABLE: i32 = 2; +pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; +pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; +pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; +pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; +pub const SQLITE_CREATE_TRIGGER: i32 = 7; +pub const SQLITE_CREATE_VIEW: i32 = 8; +pub const SQLITE_DELETE: i32 = 9; +pub const SQLITE_DROP_INDEX: i32 = 10; +pub const SQLITE_DROP_TABLE: i32 = 11; +pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; +pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; +pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; +pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; +pub const SQLITE_DROP_TRIGGER: i32 = 16; +pub const SQLITE_DROP_VIEW: i32 = 17; +pub const SQLITE_INSERT: i32 = 18; +pub const SQLITE_PRAGMA: i32 = 19; +pub const SQLITE_READ: i32 = 20; +pub const SQLITE_SELECT: i32 = 21; +pub const SQLITE_TRANSACTION: i32 = 22; +pub const SQLITE_UPDATE: i32 = 23; +pub const SQLITE_ATTACH: i32 = 24; +pub const SQLITE_DETACH: i32 = 25; +pub const SQLITE_ALTER_TABLE: i32 = 26; +pub const SQLITE_REINDEX: i32 = 27; +pub const SQLITE_ANALYZE: i32 = 28; +pub const SQLITE_CREATE_VTABLE: i32 = 29; +pub const SQLITE_DROP_VTABLE: i32 = 30; +pub const SQLITE_FUNCTION: i32 = 31; +pub const SQLITE_SAVEPOINT: i32 = 32; +pub const SQLITE_COPY: i32 = 0; +pub const SQLITE_LIMIT_LENGTH: i32 = 0; +pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; +pub const SQLITE_LIMIT_COLUMN: i32 = 2; +pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; +pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; +pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; +pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; +pub const SQLITE_LIMIT_ATTACHED: i32 = 7; +pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; +pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; +pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; +pub const SQLITE_INTEGER: i32 = 1; +pub const SQLITE_FLOAT: i32 = 2; +pub const SQLITE_BLOB: i32 = 4; +pub const SQLITE_NULL: i32 = 5; +pub const SQLITE_TEXT: i32 = 3; +pub const SQLITE3_TEXT: i32 = 3; +pub const SQLITE_UTF8: i32 = 1; +pub const SQLITE_UTF16LE: i32 = 2; +pub const SQLITE_UTF16BE: i32 = 3; +pub const SQLITE_UTF16: i32 = 4; +pub const SQLITE_ANY: i32 = 5; +pub const SQLITE_UTF16_ALIGNED: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; +pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; +pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; +pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; +pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; +pub const SQLITE_MUTEX_FAST: i32 = 0; +pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; +pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; +pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; +pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; +pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; +pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; +pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; +pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; +pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; +pub const SQLITE_TESTCTRL_FIRST: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; +pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; +pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; +pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; +pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; +pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; +pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; +pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; +pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; +pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; +pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; +pub const SQLITE_TESTCTRL_PGHDRSZ: i32 = 17; +pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 18; +pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 19; +pub const SQLITE_TESTCTRL_LAST: i32 = 19; +pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; +pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; +pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; +pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; +pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; +pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; +pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; +pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; +pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; +pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; +pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; +pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; +pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; +pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; +pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; +pub const SQLITE_DBSTATUS_MAX: i32 = 6; +pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; +pub const SQLITE_STMTSTATUS_SORT: i32 = 2; +pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; +pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; +pub const SQLITE_CHECKPOINT_FULL: i32 = 1; +pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; +pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; +pub const SQLITE_ROLLBACK: i32 = 1; +pub const SQLITE_FAIL: i32 = 3; +pub const SQLITE_REPLACE: i32 = 5; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; +extern "C" { + pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3 { + _unused: [u8; 0], +} +pub type sqlite_int64 = ::std::os::raw::c_longlong; +pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; +pub type sqlite3_int64 = sqlite_int64; +pub type sqlite3_uint64 = sqlite_uint64; +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_file { + pub pMethods: *const sqlite3_io_methods, +} +#[test] +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xShmMap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iPg: ::std::os::raw::c_int, + pgsz: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xShmLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + offset: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xShmBarrier: ::std::option::Option, + pub xShmUnmap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + deleteFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 136usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmMap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmBarrier) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmUnmap) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +pub type sqlite3_syscall_ptr = ::std::option::Option; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vfs { + pub iVersion: ::std::os::raw::c_int, + pub szOsFile: ::std::os::raw::c_int, + pub mxPathname: ::std::os::raw::c_int, + pub pNext: *mut sqlite3_vfs, + pub zName: *const ::std::os::raw::c_char, + pub pAppData: *mut ::std::os::raw::c_void, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTimeInt64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xSetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: sqlite3_syscall_ptr, + ) -> ::std::os::raw::c_int, + >, + pub xGetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> sqlite3_syscall_ptr, + >, + pub xNextSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_vfs() { + assert_eq!( + ::std::mem::size_of::(), + 168usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTimeInt64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xNextSystemCall) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mem_methods { + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub pAppData: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_mem_methods() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_stmt { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Mem { + _unused: [u8; 0], +} +pub type sqlite3_value = Mem; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_context { + _unused: [u8; 0], +} +pub type sqlite3_destructor_type = + ::std::option::Option; +extern "C" { + pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSavepoint: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRelease: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRollbackTo: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 184usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSavepoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRelease) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollbackTo) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info { + pub nConstraint: ::std::os::raw::c_int, + pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, + pub nOrderBy: ::std::os::raw::c_int, + pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, + pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, + pub idxNum: ::std::os::raw::c_int, + pub idxStr: *mut ::std::os::raw::c_char, + pub needToFreeIdxStr: ::std::os::raw::c_int, + pub orderByConsumed: ::std::os::raw::c_int, + pub estimatedCost: f64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint { + pub iColumn: ::std::os::raw::c_int, + pub op: ::std::os::raw::c_uchar, + pub usable: ::std::os::raw::c_uchar, + pub iTermOffset: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_orderby { + pub iColumn: ::std::os::raw::c_int, + pub desc: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint_usage { + pub argvIndex: ::std::os::raw::c_int, + pub omit: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); +} +#[test] +fn bindgen_test_layout_sqlite3_index_info() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_blob { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex_methods { + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_mutex_methods() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods { + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_backup { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_geometry { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut f64, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_geometry() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(xDelUser) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_api_routines { + pub aggregate_context: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub aggregate_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int, + >, + pub bind_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_double: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int, + >, + pub bind_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_int64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, + ) -> ::std::os::raw::c_int, + >, + pub bind_null: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_count: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub bind_parameter_index: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub bind_parameter_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub bind_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub busy_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub busy_timeout: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub changes: + ::std::option::Option ::std::os::raw::c_int>, + pub close: + ::std::option::Option ::std::os::raw::c_int>, + pub collation_needed: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub collation_needed16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int, + >, + pub column_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_bytes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_bytes16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub column_database_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_database_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_decltype: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_decltype16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_double: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64, + >, + pub column_int: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_int64: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64, + >, + pub column_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_origin_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_origin_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_table_name: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char, + >, + pub column_table_name16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar, + >, + pub column_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void, + >, + pub column_type: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub column_value: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value, + >, + pub commit_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub complete: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub complete16: ::std::option::Option< + unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub create_collation: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_collation16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int, + >, + pub create_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_function16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub create_module: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub data_count: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub db_handle: + ::std::option::Option *mut sqlite3>, + pub declare_vtab: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub enable_shared_cache: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub errmsg: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char, + >, + pub errmsg16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void, + >, + pub exec: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub expired: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub finalize: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub free: ::std::option::Option, + pub free_table: + ::std::option::Option, + pub get_autocommit: + ::std::option::Option ::std::os::raw::c_int>, + pub get_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub get_table: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub global_recover: ::std::option::Option ::std::os::raw::c_int>, + pub interruptx: ::std::option::Option, + pub last_insert_rowid: + ::std::option::Option sqlite_int64>, + pub libversion: ::std::option::Option *const ::std::os::raw::c_char>, + pub libversion_number: ::std::option::Option ::std::os::raw::c_int>, + pub malloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub mprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub open16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int, + >, + pub prepare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub profile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub progress_handler: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ), + >, + pub realloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub reset: ::std::option::Option< + unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub result_blob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_double: + ::std::option::Option, + pub result_error: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_error16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ), + >, + pub result_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_int64: + ::std::option::Option, + pub result_null: ::std::option::Option, + pub result_text: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16be: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_text16le: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ), + >, + pub result_value: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value), + >, + pub rollback_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub set_authorizer: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub set_auxdata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, + ), + >, + pub snprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char, + >, + pub step: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub table_column_metadata: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub thread_cleanup: ::std::option::Option, + pub total_changes: + ::std::option::Option ::std::os::raw::c_int>, + pub trace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub transfer_bindings: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int, + >, + pub update_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, + pub user_data: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void, + >, + pub value_blob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_bytes16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_double: ::std::option::Option f64>, + pub value_int: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_int64: + ::std::option::Option sqlite_int64>, + pub value_numeric_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub value_text: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar, + >, + pub value_text16: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16be: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_text16le: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void, + >, + pub value_type: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int, + >, + pub vmprintf: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char, + >, + pub overload_function: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub prepare_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub prepare16_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub clear_bindings: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int, + >, + pub create_module_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub bind_zeroblob: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_bytes: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_close: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int, + >, + pub blob_open: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int, + >, + pub blob_read: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub blob_write: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub create_collation_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub file_control: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub memory_highwater: + ::std::option::Option sqlite3_int64>, + pub memory_used: ::std::option::Option sqlite3_int64>, + pub mutex_alloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub mutex_enter: ::std::option::Option, + pub mutex_free: ::std::option::Option, + pub mutex_leave: ::std::option::Option, + pub mutex_try: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub open_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub release_memory: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub result_error_nomem: ::std::option::Option, + pub result_error_toobig: + ::std::option::Option, + pub sleep: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub soft_heap_limit: ::std::option::Option, + pub vfs_find: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs, + >, + pub vfs_register: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub vfs_unregister: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int, + >, + pub xthreadsafe: ::std::option::Option ::std::os::raw::c_int>, + pub result_zeroblob: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub result_error_code: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int), + >, + pub test_control: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int, + >, + pub randomness: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void), + >, + pub context_db_handle: + ::std::option::Option *mut sqlite3>, + pub extended_result_codes: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub limit: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub next_stmt: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt, + >, + pub sql: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char, + >, + pub status: ::std::option::Option< + unsafe extern "C" fn( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub backup_finish: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_init: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, + ) -> *mut sqlite3_backup, + >, + pub backup_pagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_remaining: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int, + >, + pub backup_step: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub compileoption_get: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char, + >, + pub compileoption_used: ::std::option::Option< + unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int, + >, + pub create_function_v2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, + pub db_config: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int, + >, + pub db_mutex: + ::std::option::Option *mut sqlite3_mutex>, + pub db_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub extended_errcode: + ::std::option::Option ::std::os::raw::c_int>, + pub log: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char, ...), + >, + pub soft_heap_limit64: + ::std::option::Option sqlite3_int64>, + pub sourceid: ::std::option::Option *const ::std::os::raw::c_char>, + pub stmt_status: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub strnicmp: ::std::option::Option< + unsafe extern "C" fn( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub unlock_notify: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub wal_autocheckpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub wal_checkpoint: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub wal_hook: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_api_routines() { + assert_eq!( + ::std::mem::size_of::(), + 1408usize, + concat!("Size of: ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_api_routines)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_context as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_context) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aggregate_count as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(aggregate_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_blob as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_double as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_int64 as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_int64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_null as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_count as *const _ + as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_index as *const _ + as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_index) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_parameter_name as *const _ + as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_parameter_name) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_text as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_text16 as *const _ as usize + }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_text16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).bind_value as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_handler as *const _ as usize + }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_handler) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).busy_timeout as *const _ as usize + }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(busy_timeout) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).changes as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).close as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(close) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed as *const _ as usize + }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).collation_needed16 as *const _ as usize + }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(collation_needed16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_blob as *const _ as usize + }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes as *const _ as usize + }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_bytes16 as *const _ as usize + }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_count as *const _ as usize + }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_count) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name as *const _ + as usize + }, + 184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_database_name16 as *const _ + as usize + }, + 192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_database_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype as *const _ as usize + }, + 200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_decltype16 as *const _ as usize + }, + 208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_decltype16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_double as *const _ as usize + }, + 216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).column_int as *const _ as usize }, + 224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_int64 as *const _ as usize + }, + 232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name as *const _ as usize + }, + 240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_name16 as *const _ as usize + }, + 248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name as *const _ as usize + }, + 256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_origin_name16 as *const _ + as usize + }, + 264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_origin_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name as *const _ as usize + }, + 272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_table_name16 as *const _ + as usize + }, + 280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_table_name16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text as *const _ as usize + }, + 288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_text16 as *const _ as usize + }, + 296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_type as *const _ as usize + }, + 304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_type) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).column_value as *const _ as usize + }, + 312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(column_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).commit_hook as *const _ as usize + }, + 320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(commit_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete as *const _ as usize }, + 328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).complete16 as *const _ as usize }, + 336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(complete16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation as *const _ as usize + }, + 344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation16 as *const _ as usize + }, + 352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function as *const _ as usize + }, + 360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function16 as *const _ as usize + }, + 368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module as *const _ as usize + }, + 376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).data_count as *const _ as usize }, + 384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(data_count) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_handle as *const _ as usize }, + 392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).declare_vtab as *const _ as usize + }, + 400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(declare_vtab) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).enable_shared_cache as *const _ + as usize + }, + 408usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(enable_shared_cache) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errcode as *const _ as usize }, + 416usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg as *const _ as usize }, + 424usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).errmsg16 as *const _ as usize }, + 432usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(errmsg16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).exec as *const _ as usize }, + 440usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(exec) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).expired as *const _ as usize }, + 448usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(expired) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).finalize as *const _ as usize }, + 456usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(finalize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free as *const _ as usize }, + 464usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).free_table as *const _ as usize }, + 472usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(free_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_autocommit as *const _ as usize + }, + 480usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_autocommit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).get_auxdata as *const _ as usize + }, + 488usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).get_table as *const _ as usize }, + 496usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(get_table) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).global_recover as *const _ as usize + }, + 504usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(global_recover) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).interruptx as *const _ as usize }, + 512usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(interruptx) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).last_insert_rowid as *const _ as usize + }, + 520usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(last_insert_rowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).libversion as *const _ as usize }, + 528usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).libversion_number as *const _ as usize + }, + 536usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(libversion_number) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).malloc as *const _ as usize }, + 544usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(malloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mprintf as *const _ as usize }, + 552usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open as *const _ as usize }, + 560usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open16 as *const _ as usize }, + 568usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare as *const _ as usize }, + 576usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare16 as *const _ as usize }, + 584usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).profile as *const _ as usize }, + 592usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(profile) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).progress_handler as *const _ as usize + }, + 600usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(progress_handler) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).realloc as *const _ as usize }, + 608usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(realloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).reset as *const _ as usize }, + 616usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(reset) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_blob as *const _ as usize + }, + 624usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_double as *const _ as usize + }, + 632usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_double) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error as *const _ as usize + }, + 640usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error16 as *const _ as usize + }, + 648usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error16) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).result_int as *const _ as usize }, + 656usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_int64 as *const _ as usize + }, + 664usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_null as *const _ as usize + }, + 672usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_null) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text as *const _ as usize + }, + 680usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16 as *const _ as usize + }, + 688usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16be as *const _ as usize + }, + 696usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_text16le as *const _ as usize + }, + 704usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_text16le) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_value as *const _ as usize + }, + 712usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_value) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).rollback_hook as *const _ as usize + }, + 720usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(rollback_hook) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_authorizer as *const _ as usize + }, + 728usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_authorizer) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).set_auxdata as *const _ as usize + }, + 736usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(set_auxdata) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).snprintf as *const _ as usize }, + 744usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(snprintf) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).step as *const _ as usize }, + 752usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).table_column_metadata as *const _ + as usize + }, + 760usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(table_column_metadata) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).thread_cleanup as *const _ as usize + }, + 768usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(thread_cleanup) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).total_changes as *const _ as usize + }, + 776usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(total_changes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).trace as *const _ as usize }, + 784usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(trace) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).transfer_bindings as *const _ as usize + }, + 792usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(transfer_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).update_hook as *const _ as usize + }, + 800usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(update_hook) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).user_data as *const _ as usize }, + 808usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(user_data) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_blob as *const _ as usize }, + 816usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_blob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes as *const _ as usize + }, + 824usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_bytes16 as *const _ as usize + }, + 832usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_bytes16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_double as *const _ as usize + }, + 840usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_double) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_int as *const _ as usize }, + 848usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_int64 as *const _ as usize + }, + 856usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_int64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_numeric_type as *const _ as usize + }, + 864usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_numeric_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_text as *const _ as usize }, + 872usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16 as *const _ as usize + }, + 880usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16be as *const _ as usize + }, + 888usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16be) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).value_text16le as *const _ as usize + }, + 896usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_text16le) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).value_type as *const _ as usize }, + 904usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(value_type) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vmprintf as *const _ as usize }, + 912usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vmprintf) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).overload_function as *const _ as usize + }, + 920usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(overload_function) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).prepare_v2 as *const _ as usize }, + 928usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).prepare16_v2 as *const _ as usize + }, + 936usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(prepare16_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).clear_bindings as *const _ as usize + }, + 944usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(clear_bindings) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_module_v2 as *const _ as usize + }, + 952usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_module_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).bind_zeroblob as *const _ as usize + }, + 960usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(bind_zeroblob) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_bytes as *const _ as usize }, + 968usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_bytes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_close as *const _ as usize }, + 976usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_close) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_open as *const _ as usize }, + 984usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_open) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_read as *const _ as usize }, + 992usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_read) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).blob_write as *const _ as usize }, + 1000usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(blob_write) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_collation_v2 as *const _ + as usize + }, + 1008usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_collation_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).file_control as *const _ as usize + }, + 1016usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(file_control) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_highwater as *const _ as usize + }, + 1024usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_highwater) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).memory_used as *const _ as usize + }, + 1032usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(memory_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_alloc as *const _ as usize + }, + 1040usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_alloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_enter as *const _ as usize + }, + 1048usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_enter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_free as *const _ as usize }, + 1056usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_free) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).mutex_leave as *const _ as usize + }, + 1064usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_leave) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mutex_try as *const _ as usize }, + 1072usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(mutex_try) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).open_v2 as *const _ as usize }, + 1080usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(open_v2) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).release_memory as *const _ as usize + }, + 1088usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(release_memory) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_nomem as *const _ as usize + }, + 1096usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_nomem) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_toobig as *const _ + as usize + }, + 1104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_toobig) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sleep as *const _ as usize }, + 1112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sleep) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit as *const _ as usize + }, + 1120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).vfs_find as *const _ as usize }, + 1128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_find) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_register as *const _ as usize + }, + 1136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_register) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).vfs_unregister as *const _ as usize + }, + 1144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(vfs_unregister) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xthreadsafe as *const _ as usize + }, + 1152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(xthreadsafe) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_zeroblob as *const _ as usize + }, + 1160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_zeroblob) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).result_error_code as *const _ as usize + }, + 1168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(result_error_code) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).test_control as *const _ as usize + }, + 1176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(test_control) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).randomness as *const _ as usize }, + 1184usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(randomness) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).context_db_handle as *const _ as usize + }, + 1192usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(context_db_handle) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_result_codes as *const _ + as usize + }, + 1200usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_result_codes) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).limit as *const _ as usize }, + 1208usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(limit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).next_stmt as *const _ as usize }, + 1216usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(next_stmt) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sql as *const _ as usize }, + 1224usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sql) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).status as *const _ as usize }, + 1232usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_finish as *const _ as usize + }, + 1240usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_finish) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_init as *const _ as usize + }, + 1248usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_init) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_pagecount as *const _ as usize + }, + 1256usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_pagecount) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_remaining as *const _ as usize + }, + 1264usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_remaining) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).backup_step as *const _ as usize + }, + 1272usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(backup_step) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_get as *const _ as usize + }, + 1280usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_get) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).compileoption_used as *const _ as usize + }, + 1288usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(compileoption_used) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).create_function_v2 as *const _ as usize + }, + 1296usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(create_function_v2) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_config as *const _ as usize }, + 1304usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_config) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_mutex as *const _ as usize }, + 1312usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_mutex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).db_status as *const _ as usize }, + 1320usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(db_status) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).extended_errcode as *const _ as usize + }, + 1328usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(extended_errcode) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).log as *const _ as usize }, + 1336usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(log) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).soft_heap_limit64 as *const _ as usize + }, + 1344usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(soft_heap_limit64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).sourceid as *const _ as usize }, + 1352usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(sourceid) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).stmt_status as *const _ as usize + }, + 1360usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(stmt_status) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).strnicmp as *const _ as usize }, + 1368usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(strnicmp) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).unlock_notify as *const _ as usize + }, + 1376usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(unlock_notify) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_autocheckpoint as *const _ as usize + }, + 1384usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_autocheckpoint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).wal_checkpoint as *const _ as usize + }, + 1392usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_checkpoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).wal_hook as *const _ as usize }, + 1400usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(wal_hook) + ) + ); +} +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} + +// sqlite3_api is defined in lib.rs as either a static or an extern when compiled as a loadable_extension +use crate::sqlite3_api; + +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) + +pub unsafe fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_context.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_context", + " function" + )))(arg1, nBytes) +} + +pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).aggregate_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "aggregate_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_blob", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_double", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite_int64, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_int64", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_null", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_count", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_index.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_index", + " function" + )))(arg1, zName) +} + +pub unsafe fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_parameter_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_parameter_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text", + " function" + )))(arg1, arg2, arg3, n, arg4) +} + +pub unsafe fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_text16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_value", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_handler", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).busy_timeout.expect(stringify!( + "sqlite3_api contains null pointer for ", + "busy_timeout", + " function" + )))(arg1, ms) +} + +pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).collation_needed16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "collation_needed16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_blob", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_bytes16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_database_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_database_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + i: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype", + " function" + )))(arg1, i) +} + +pub unsafe fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_decltype16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_decltype16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_double", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_int64", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_origin_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_origin_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_table_name16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_table_name16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_text16", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_type", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, +) -> *mut sqlite3_value { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).column_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "column_value", + " function" + )))(arg1, iCol) +} + +pub unsafe fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).commit_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "commit_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).complete16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "complete16", + " function" + )))(sql) +} + +pub unsafe fn sqlite3_create_collation( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_collation16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_create_function( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_function16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function16", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal) +} + +pub unsafe fn sqlite3_create_module( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).data_count.expect(stringify!( + "sqlite3_api contains null pointer for ", + "data_count", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).declare_vtab.expect(stringify!( + "sqlite3_api contains null pointer for ", + "declare_vtab", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).enable_shared_cache.expect(stringify!( + "sqlite3_api contains null pointer for ", + "enable_shared_cache", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errcode", + " function" + )))(db) +} + +pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).errmsg16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "errmsg16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_exec( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_callback, + arg4: *mut ::std::os::raw::c_void, + arg5: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).exec.expect(stringify!( + "sqlite3_api contains null pointer for ", + "exec", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).expired.expect(stringify!( + "sqlite3_api contains null pointer for ", + "expired", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).finalize.expect(stringify!( + "sqlite3_api contains null pointer for ", + "finalize", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).free_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "free_table", + " function" + )))(result) +} + +pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_autocommit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_autocommit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_auxdata", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_get_table( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut *mut *mut ::std::os::raw::c_char, + arg4: *mut ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_int, + arg6: *mut *mut ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).get_table.expect(stringify!( + "sqlite3_api contains null pointer for ", + "get_table", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).global_recover.expect(stringify!( + "sqlite3_api contains null pointer for ", + "global_recover", + " function" + )))() +} + +pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).interruptx.expect(stringify!( + "sqlite3_api contains null pointer for ", + "interruptx", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).last_insert_rowid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "last_insert_rowid", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion", + " function" + )))() +} + +pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).libversion_number.expect(stringify!( + "sqlite3_api contains null pointer for ", + "libversion_number", + " function" + )))() +} + +pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).malloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "malloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mprintf", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_open( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_open16( + arg1: *const ::std::os::raw::c_void, + arg2: *mut *mut sqlite3, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open16", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_prepare( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_profile( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite_uint64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).profile.expect(stringify!( + "sqlite3_api contains null pointer for ", + "profile", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).progress_handler.expect(stringify!( + "sqlite3_api contains null pointer for ", + "progress_handler", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).realloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "realloc", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).reset.expect(stringify!( + "sqlite3_api contains null pointer for ", + "reset", + " function" + )))(pStmt) +} + +pub unsafe fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_blob", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_double", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error16", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_int64", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_null.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_null", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16be", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_text16le", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_value.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_value", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).rollback_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "rollback_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_authorizer.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_authorizer", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, +) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).set_auxdata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "set_auxdata", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_snprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).snprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "snprintf", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "step", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_table_column_metadata( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *mut *const ::std::os::raw::c_char, + arg6: *mut *const ::std::os::raw::c_char, + arg7: *mut ::std::os::raw::c_int, + arg8: *mut ::std::os::raw::c_int, + arg9: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).table_column_metadata.expect(stringify!( + "sqlite3_api contains null pointer for ", + "table_column_metadata", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) +} + +pub unsafe fn sqlite3_thread_cleanup() { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).thread_cleanup.expect(stringify!( + "sqlite3_api contains null pointer for ", + "thread_cleanup", + " function" + )))() +} + +pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).total_changes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "total_changes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).trace.expect(stringify!( + "sqlite3_api contains null pointer for ", + "trace", + " function" + )))(arg1, xTrace, arg2) +} + +pub unsafe fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).transfer_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "transfer_bindings", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).update_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "update_hook", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).user_data.expect(stringify!( + "sqlite3_api contains null pointer for ", + "user_data", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_blob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_blob", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_bytes16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_bytes16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_double.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_double", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_int64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_int64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_numeric_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_numeric_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16be.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16be", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_text16le.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_text16le", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).value_type.expect(stringify!( + "sqlite3_api contains null pointer for ", + "value_type", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, +) -> *mut ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vmprintf.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vmprintf", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).overload_function.expect(stringify!( + "sqlite3_api contains null pointer for ", + "overload_function", + " function" + )))(arg1, zFuncName, nArg) +} + +pub unsafe fn sqlite3_prepare_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_prepare16_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: *mut *mut sqlite3_stmt, + arg5: *mut *const ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).prepare16_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "prepare16_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).clear_bindings.expect(stringify!( + "sqlite3_api contains null pointer for ", + "clear_bindings", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_module_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const sqlite3_module, + arg4: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_module_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_module_v2", + " function" + )))(arg1, arg2, arg3, arg4, xDestroy) +} + +pub unsafe fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).bind_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "bind_zeroblob", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_bytes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_bytes", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_close.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_close", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_blob_open( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + arg6: ::std::os::raw::c_int, + arg7: *mut *mut sqlite3_blob, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_open.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_open", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6, arg7) +} + +pub unsafe fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_read.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_read", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).blob_write.expect(stringify!( + "sqlite3_api contains null pointer for ", + "blob_write", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, + arg5: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + arg6: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_collation_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_collation_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, arg6) +} + +pub unsafe fn sqlite3_file_control( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).file_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "file_control", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_highwater.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_highwater", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).memory_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "memory_used", + " function" + )))() +} + +pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_alloc.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_alloc", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_enter.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_enter", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_free.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_free", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_leave.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_leave", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).mutex_try.expect(stringify!( + "sqlite3_api contains null pointer for ", + "mutex_try", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_open_v2( + arg1: *const ::std::os::raw::c_char, + arg2: *mut *mut sqlite3, + arg3: ::std::os::raw::c_int, + arg4: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).open_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "open_v2", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).release_memory.expect(stringify!( + "sqlite3_api contains null pointer for ", + "release_memory", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_nomem.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_nomem", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_toobig.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_toobig", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sleep.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sleep", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_find.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_find", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_register.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_register", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vfs_unregister.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vfs_unregister", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).xthreadsafe.expect(stringify!( + "sqlite3_api contains null pointer for ", + "xthreadsafe", + " function" + )))() +} + +pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_zeroblob.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_zeroblob", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).result_error_code.expect(stringify!( + "sqlite3_api contains null pointer for ", + "result_error_code", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_test_control(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).test_control.expect(stringify!( + "sqlite3_api contains null pointer for ", + "test_control", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).randomness.expect(stringify!( + "sqlite3_api contains null pointer for ", + "randomness", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).context_db_handle.expect(stringify!( + "sqlite3_api contains null pointer for ", + "context_db_handle", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_result_codes.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_result_codes", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_limit( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).limit.expect(stringify!( + "sqlite3_api contains null pointer for ", + "limit", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).next_stmt.expect(stringify!( + "sqlite3_api contains null pointer for ", + "next_stmt", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sql.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sql", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_status( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "status", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_finish.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_finish", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_init( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: *mut sqlite3, + arg4: *const ::std::os::raw::c_char, +) -> *mut sqlite3_backup { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_init.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_init", + " function" + )))(arg1, arg2, arg3, arg4) +} + +pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_pagecount.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_pagecount", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_remaining.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_remaining", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_backup_step( + arg1: *mut sqlite3_backup, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).backup_step.expect(stringify!( + "sqlite3_api contains null pointer for ", + "backup_step", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_compileoption_get( + arg1: ::std::os::raw::c_int, +) -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_get.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_get", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_compileoption_used( + arg1: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).compileoption_used.expect(stringify!( + "sqlite3_api contains null pointer for ", + "compileoption_used", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_create_function_v2( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::os::raw::c_int, + arg5: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).create_function_v2.expect(stringify!( + "sqlite3_api contains null pointer for ", + "create_function_v2", + " function" + )))(arg1, arg2, arg3, arg4, arg5, xFunc, xStep, xFinal, xDestroy) +} + +pub unsafe fn sqlite3_db_config( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_config", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_db_config_constchar( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + vararg1: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_config", + " function" + )))(arg1, arg2, vararg1) +} + +pub unsafe fn sqlite3_db_config_int_mutint( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + vararg1: ::std::os::raw::c_int, + vararg2: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_config", + " function" + )))(arg1, arg2, vararg1, vararg2) +} + +pub unsafe fn sqlite3_db_config_void_int_mutint( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + vararg1: *mut ::core::ffi::c_void, + vararg2: ::std::os::raw::c_int, + vararg3: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_config", + " function" + )))(arg1, arg2, vararg1, vararg2, vararg3) +} + +pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_mutex.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_mutex", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_db_status( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_int, + arg4: *mut ::std::os::raw::c_int, + arg5: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_status", + " function" + )))(arg1, arg2, arg3, arg4, arg5) +} + +pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).extended_errcode.expect(stringify!( + "sqlite3_api contains null pointer for ", + "extended_errcode", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_log(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char) { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).log.expect(stringify!( + "sqlite3_api contains null pointer for ", + "log", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).soft_heap_limit64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "soft_heap_limit64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).sourceid.expect(stringify!( + "sqlite3_api contains null pointer for ", + "sourceid", + " function" + )))() +} + +pub unsafe fn sqlite3_stmt_status( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).stmt_status.expect(stringify!( + "sqlite3_api contains null pointer for ", + "stmt_status", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_strnicmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).strnicmp.expect(stringify!( + "sqlite3_api contains null pointer for ", + "strnicmp", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_unlock_notify( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int), + >, + arg3: *mut ::std::os::raw::c_void, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).unlock_notify.expect(stringify!( + "sqlite3_api contains null pointer for ", + "unlock_notify", + " function" + )))(arg1, arg2, arg3) +} + +pub unsafe fn sqlite3_wal_autocheckpoint( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_autocheckpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_checkpoint( + arg1: *mut sqlite3, + arg2: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_checkpoint.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_checkpoint", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_wal_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, +) -> *mut ::std::os::raw::c_void { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).wal_hook.expect(stringify!( + "sqlite3_api contains null pointer for ", + "wal_hook", + " function" + )))(arg1, arg2, arg3) +} diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7.rs new file mode 100644 index 000000000..549d9a9a3 --- /dev/null +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7.rs @@ -0,0 +1,3506 @@ +/* automatically generated by rust-bindgen 0.57.0 */ + +pub const __GNUC_VA_LIST: i32 = 1; +pub const SQLITE_VERSION: &'static [u8; 6usize] = b"3.7.7\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3007007; +pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = + b"2011-06-23 19:49:22 4374b7e83ea0a3fbc3691f9c0c936272862f32f2\0"; +pub const SQLITE_OK: i32 = 0; +pub const SQLITE_ERROR: i32 = 1; +pub const SQLITE_INTERNAL: i32 = 2; +pub const SQLITE_PERM: i32 = 3; +pub const SQLITE_ABORT: i32 = 4; +pub const SQLITE_BUSY: i32 = 5; +pub const SQLITE_LOCKED: i32 = 6; +pub const SQLITE_NOMEM: i32 = 7; +pub const SQLITE_READONLY: i32 = 8; +pub const SQLITE_INTERRUPT: i32 = 9; +pub const SQLITE_IOERR: i32 = 10; +pub const SQLITE_CORRUPT: i32 = 11; +pub const SQLITE_NOTFOUND: i32 = 12; +pub const SQLITE_FULL: i32 = 13; +pub const SQLITE_CANTOPEN: i32 = 14; +pub const SQLITE_PROTOCOL: i32 = 15; +pub const SQLITE_EMPTY: i32 = 16; +pub const SQLITE_SCHEMA: i32 = 17; +pub const SQLITE_TOOBIG: i32 = 18; +pub const SQLITE_CONSTRAINT: i32 = 19; +pub const SQLITE_MISMATCH: i32 = 20; +pub const SQLITE_MISUSE: i32 = 21; +pub const SQLITE_NOLFS: i32 = 22; +pub const SQLITE_AUTH: i32 = 23; +pub const SQLITE_FORMAT: i32 = 24; +pub const SQLITE_RANGE: i32 = 25; +pub const SQLITE_NOTADB: i32 = 26; +pub const SQLITE_ROW: i32 = 100; +pub const SQLITE_DONE: i32 = 101; +pub const SQLITE_IOERR_READ: i32 = 266; +pub const SQLITE_IOERR_SHORT_READ: i32 = 522; +pub const SQLITE_IOERR_WRITE: i32 = 778; +pub const SQLITE_IOERR_FSYNC: i32 = 1034; +pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290; +pub const SQLITE_IOERR_TRUNCATE: i32 = 1546; +pub const SQLITE_IOERR_FSTAT: i32 = 1802; +pub const SQLITE_IOERR_UNLOCK: i32 = 2058; +pub const SQLITE_IOERR_RDLOCK: i32 = 2314; +pub const SQLITE_IOERR_DELETE: i32 = 2570; +pub const SQLITE_IOERR_BLOCKED: i32 = 2826; +pub const SQLITE_IOERR_NOMEM: i32 = 3082; +pub const SQLITE_IOERR_ACCESS: i32 = 3338; +pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594; +pub const SQLITE_IOERR_LOCK: i32 = 3850; +pub const SQLITE_IOERR_CLOSE: i32 = 4106; +pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362; +pub const SQLITE_IOERR_SHMOPEN: i32 = 4618; +pub const SQLITE_IOERR_SHMSIZE: i32 = 4874; +pub const SQLITE_IOERR_SHMLOCK: i32 = 5130; +pub const SQLITE_IOERR_SHMMAP: i32 = 5386; +pub const SQLITE_IOERR_SEEK: i32 = 5642; +pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262; +pub const SQLITE_BUSY_RECOVERY: i32 = 261; +pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270; +pub const SQLITE_CORRUPT_VTAB: i32 = 267; +pub const SQLITE_READONLY_RECOVERY: i32 = 264; +pub const SQLITE_READONLY_CANTLOCK: i32 = 520; +pub const SQLITE_OPEN_READONLY: i32 = 1; +pub const SQLITE_OPEN_READWRITE: i32 = 2; +pub const SQLITE_OPEN_CREATE: i32 = 4; +pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8; +pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16; +pub const SQLITE_OPEN_AUTOPROXY: i32 = 32; +pub const SQLITE_OPEN_URI: i32 = 64; +pub const SQLITE_OPEN_MAIN_DB: i32 = 256; +pub const SQLITE_OPEN_TEMP_DB: i32 = 512; +pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024; +pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048; +pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096; +pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192; +pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; +pub const SQLITE_OPEN_NOMUTEX: i32 = 32768; +pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536; +pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; +pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; +pub const SQLITE_OPEN_WAL: i32 = 524288; +pub const SQLITE_IOCAP_ATOMIC: i32 = 1; +pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; +pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4; +pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8; +pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16; +pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32; +pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64; +pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128; +pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256; +pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512; +pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024; +pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048; +pub const SQLITE_LOCK_NONE: i32 = 0; +pub const SQLITE_LOCK_SHARED: i32 = 1; +pub const SQLITE_LOCK_RESERVED: i32 = 2; +pub const SQLITE_LOCK_PENDING: i32 = 3; +pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4; +pub const SQLITE_SYNC_NORMAL: i32 = 2; +pub const SQLITE_SYNC_FULL: i32 = 3; +pub const SQLITE_SYNC_DATAONLY: i32 = 16; +pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1; +pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; +pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; +pub const SQLITE_LAST_ERRNO: i32 = 4; +pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5; +pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6; +pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7; +pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8; +pub const SQLITE_ACCESS_EXISTS: i32 = 0; +pub const SQLITE_ACCESS_READWRITE: i32 = 1; +pub const SQLITE_ACCESS_READ: i32 = 2; +pub const SQLITE_SHM_UNLOCK: i32 = 1; +pub const SQLITE_SHM_LOCK: i32 = 2; +pub const SQLITE_SHM_SHARED: i32 = 4; +pub const SQLITE_SHM_EXCLUSIVE: i32 = 8; +pub const SQLITE_SHM_NLOCK: i32 = 8; +pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1; +pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2; +pub const SQLITE_CONFIG_SERIALIZED: i32 = 3; +pub const SQLITE_CONFIG_MALLOC: i32 = 4; +pub const SQLITE_CONFIG_GETMALLOC: i32 = 5; +pub const SQLITE_CONFIG_SCRATCH: i32 = 6; +pub const SQLITE_CONFIG_PAGECACHE: i32 = 7; +pub const SQLITE_CONFIG_HEAP: i32 = 8; +pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9; +pub const SQLITE_CONFIG_MUTEX: i32 = 10; +pub const SQLITE_CONFIG_GETMUTEX: i32 = 11; +pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13; +pub const SQLITE_CONFIG_PCACHE: i32 = 14; +pub const SQLITE_CONFIG_GETPCACHE: i32 = 15; +pub const SQLITE_CONFIG_LOG: i32 = 16; +pub const SQLITE_CONFIG_URI: i32 = 17; +pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001; +pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002; +pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003; +pub const SQLITE_DENY: i32 = 1; +pub const SQLITE_IGNORE: i32 = 2; +pub const SQLITE_CREATE_INDEX: i32 = 1; +pub const SQLITE_CREATE_TABLE: i32 = 2; +pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3; +pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4; +pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5; +pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6; +pub const SQLITE_CREATE_TRIGGER: i32 = 7; +pub const SQLITE_CREATE_VIEW: i32 = 8; +pub const SQLITE_DELETE: i32 = 9; +pub const SQLITE_DROP_INDEX: i32 = 10; +pub const SQLITE_DROP_TABLE: i32 = 11; +pub const SQLITE_DROP_TEMP_INDEX: i32 = 12; +pub const SQLITE_DROP_TEMP_TABLE: i32 = 13; +pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14; +pub const SQLITE_DROP_TEMP_VIEW: i32 = 15; +pub const SQLITE_DROP_TRIGGER: i32 = 16; +pub const SQLITE_DROP_VIEW: i32 = 17; +pub const SQLITE_INSERT: i32 = 18; +pub const SQLITE_PRAGMA: i32 = 19; +pub const SQLITE_READ: i32 = 20; +pub const SQLITE_SELECT: i32 = 21; +pub const SQLITE_TRANSACTION: i32 = 22; +pub const SQLITE_UPDATE: i32 = 23; +pub const SQLITE_ATTACH: i32 = 24; +pub const SQLITE_DETACH: i32 = 25; +pub const SQLITE_ALTER_TABLE: i32 = 26; +pub const SQLITE_REINDEX: i32 = 27; +pub const SQLITE_ANALYZE: i32 = 28; +pub const SQLITE_CREATE_VTABLE: i32 = 29; +pub const SQLITE_DROP_VTABLE: i32 = 30; +pub const SQLITE_FUNCTION: i32 = 31; +pub const SQLITE_SAVEPOINT: i32 = 32; +pub const SQLITE_COPY: i32 = 0; +pub const SQLITE_LIMIT_LENGTH: i32 = 0; +pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1; +pub const SQLITE_LIMIT_COLUMN: i32 = 2; +pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3; +pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4; +pub const SQLITE_LIMIT_VDBE_OP: i32 = 5; +pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6; +pub const SQLITE_LIMIT_ATTACHED: i32 = 7; +pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8; +pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9; +pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10; +pub const SQLITE_INTEGER: i32 = 1; +pub const SQLITE_FLOAT: i32 = 2; +pub const SQLITE_BLOB: i32 = 4; +pub const SQLITE_NULL: i32 = 5; +pub const SQLITE_TEXT: i32 = 3; +pub const SQLITE3_TEXT: i32 = 3; +pub const SQLITE_UTF8: i32 = 1; +pub const SQLITE_UTF16LE: i32 = 2; +pub const SQLITE_UTF16BE: i32 = 3; +pub const SQLITE_UTF16: i32 = 4; +pub const SQLITE_ANY: i32 = 5; +pub const SQLITE_UTF16_ALIGNED: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2; +pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4; +pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8; +pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16; +pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32; +pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64; +pub const SQLITE_MUTEX_FAST: i32 = 0; +pub const SQLITE_MUTEX_RECURSIVE: i32 = 1; +pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2; +pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3; +pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4; +pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4; +pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5; +pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6; +pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7; +pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7; +pub const SQLITE_TESTCTRL_FIRST: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5; +pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6; +pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7; +pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8; +pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9; +pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10; +pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11; +pub const SQLITE_TESTCTRL_ASSERT: i32 = 12; +pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13; +pub const SQLITE_TESTCTRL_RESERVE: i32 = 14; +pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15; +pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16; +pub const SQLITE_TESTCTRL_PGHDRSZ: i32 = 17; +pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 18; +pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 19; +pub const SQLITE_TESTCTRL_LAST: i32 = 19; +pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; +pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; +pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; +pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3; +pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4; +pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5; +pub const SQLITE_STATUS_PARSER_STACK: i32 = 6; +pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7; +pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8; +pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9; +pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0; +pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1; +pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2; +pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3; +pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5; +pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6; +pub const SQLITE_DBSTATUS_MAX: i32 = 6; +pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1; +pub const SQLITE_STMTSTATUS_SORT: i32 = 2; +pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3; +pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0; +pub const SQLITE_CHECKPOINT_FULL: i32 = 1; +pub const SQLITE_CHECKPOINT_RESTART: i32 = 2; +pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1; +pub const SQLITE_ROLLBACK: i32 = 1; +pub const SQLITE_FAIL: i32 = 3; +pub const SQLITE_REPLACE: i32 = 5; +pub type va_list = __builtin_va_list; +pub type __gnuc_va_list = __builtin_va_list; +extern "C" { + pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; +} +extern "C" { + pub fn sqlite3_libversion() -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_sourceid() -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_libversion_number() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_compileoption_used( + zOptName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_compileoption_get(N: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_threadsafe() -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3 { + _unused: [u8; 0], +} +pub type sqlite_int64 = ::std::os::raw::c_longlong; +pub type sqlite_uint64 = ::std::os::raw::c_ulonglong; +pub type sqlite3_int64 = sqlite_int64; +pub type sqlite3_uint64 = sqlite_uint64; +extern "C" { + pub fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +pub type sqlite3_callback = ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, +>; +extern "C" { + pub fn sqlite3_exec( + arg1: *mut sqlite3, + sql: *const ::std::os::raw::c_char, + callback: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_char, + arg4: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + arg2: *mut ::std::os::raw::c_void, + errmsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_file { + pub pMethods: *const sqlite3_io_methods, +} +#[test] +fn bindgen_test_layout_sqlite3_file() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_file)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_file)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pMethods as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_file), + "::", + stringify!(pMethods) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_io_methods { + pub iVersion: ::std::os::raw::c_int, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xRead: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *mut ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xWrite: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: *const ::std::os::raw::c_void, + iAmt: ::std::os::raw::c_int, + iOfst: sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileSize: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pSize: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xUnlock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCheckReservedLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFileControl: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + op: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xSectorSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xDeviceCharacteristics: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int, + >, + pub xShmMap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + iPg: ::std::os::raw::c_int, + pgsz: ::std::os::raw::c_int, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xShmLock: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + offset: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + flags: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xShmBarrier: ::std::option::Option, + pub xShmUnmap: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_file, + deleteFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_io_methods() { + assert_eq!( + ::std::mem::size_of::(), + 136usize, + concat!("Size of: ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_io_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRead as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xRead) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xWrite as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xWrite) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xTruncate as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileSize as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xLock as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnlock as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xUnlock) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCheckReservedLock as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xCheckReservedLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFileControl as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xFileControl) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSectorSize as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xSectorSize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xDeviceCharacteristics as *const _ + as usize + }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xDeviceCharacteristics) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmMap as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmMap) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmLock as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmLock) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmBarrier as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmBarrier) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShmUnmap as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_io_methods), + "::", + stringify!(xShmUnmap) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex { + _unused: [u8; 0], +} +pub type sqlite3_syscall_ptr = ::std::option::Option; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vfs { + pub iVersion: ::std::os::raw::c_int, + pub szOsFile: ::std::os::raw::c_int, + pub mxPathname: ::std::os::raw::c_int, + pub pNext: *mut sqlite3_vfs, + pub zName: *const ::std::os::raw::c_char, + pub pAppData: *mut ::std::os::raw::c_void, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: *mut sqlite3_file, + flags: ::std::os::raw::c_int, + pOutFlags: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xDelete: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + syncDir: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xAccess: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + flags: ::std::os::raw::c_int, + pResOut: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xFullPathname: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + nOut: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xDlOpen: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zFilename: *const ::std::os::raw::c_char, + ) -> *mut ::std::os::raw::c_void, + >, + pub xDlError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zErrMsg: *mut ::std::os::raw::c_char, + ), + >, + pub xDlSym: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ) -> ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut ::std::os::raw::c_void, + zSymbol: *const ::std::os::raw::c_char, + ), + >, + >, + pub xDlClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void), + >, + pub xRandomness: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + nByte: ::std::os::raw::c_int, + zOut: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSleep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + microseconds: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTime: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int, + >, + pub xGetLastError: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: ::std::os::raw::c_int, + arg3: *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xCurrentTimeInt64: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + arg2: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xSetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + arg2: sqlite3_syscall_ptr, + ) -> ::std::os::raw::c_int, + >, + pub xGetSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> sqlite3_syscall_ptr, + >, + pub xNextSystemCall: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vfs, + zName: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_vfs() { + assert_eq!( + ::std::mem::size_of::(), + 168usize, + concat!("Size of: ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vfs)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).szOsFile as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(szOsFile) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).mxPathname as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(mxPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pNext as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zName as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(zName) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(pAppData) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelete as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDelete) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xAccess as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xAccess) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFullPathname as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xFullPathname) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlOpen as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlError as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlSym as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlSym) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDlClose as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xDlClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRandomness as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xRandomness) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSleep as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSleep) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTime as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTime) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetLastError as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetLastError) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCurrentTimeInt64 as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xCurrentTimeInt64) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSetSystemCall as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xSetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xGetSystemCall as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xGetSystemCall) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNextSystemCall as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vfs), + "::", + stringify!(xNextSystemCall) + ) + ); +} +extern "C" { + pub fn sqlite3_initialize() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_shutdown() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_os_init() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_os_end() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_config(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_db_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mem_methods { + pub xMalloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void, + >, + pub xFree: ::std::option::Option, + pub xRealloc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xSize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xRoundup: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int, + >, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub pAppData: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout_sqlite3_mem_methods() { + assert_eq!( + ::std::mem::size_of::(), + 64usize, + concat!("Size of: ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mem_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMalloc as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xMalloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFree as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xFree) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRealloc as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRealloc) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSize as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xSize) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRoundup as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xRoundup) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xShutdown as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pAppData as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mem_methods), + "::", + stringify!(pAppData) + ) + ); +} +extern "C" { + pub fn sqlite3_extended_result_codes( + arg1: *mut sqlite3, + onoff: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_interrupt(arg1: *mut sqlite3); +} +extern "C" { + pub fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_busy_handler( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_busy_timeout( + arg1: *mut sqlite3, + ms: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_get_table( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + pazResult: *mut *mut *mut ::std::os::raw::c_char, + pnRow: *mut ::std::os::raw::c_int, + pnColumn: *mut ::std::os::raw::c_int, + pzErrmsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char); +} +extern "C" { + pub fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char, ...) + -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_vmprintf( + arg1: *const ::std::os::raw::c_char, + arg2: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_snprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + ... + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_vsnprintf( + arg1: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_char, + arg3: *const ::std::os::raw::c_char, + arg4: *mut __va_list_tag, + ) -> *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_realloc( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_free(arg1: *mut ::std::os::raw::c_void); +} +extern "C" { + pub fn sqlite3_memory_used() -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_memory_highwater(resetFlag: ::std::os::raw::c_int) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_randomness(N: ::std::os::raw::c_int, P: *mut ::std::os::raw::c_void); +} +extern "C" { + pub fn sqlite3_set_authorizer( + arg1: *mut sqlite3, + xAuth: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: *const ::std::os::raw::c_char, + arg6: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pUserData: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_trace( + arg1: *mut sqlite3, + xTrace: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_profile( + arg1: *mut sqlite3, + xProfile: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: sqlite3_uint64, + ), + >, + arg2: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_progress_handler( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + arg3: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg4: *mut ::std::os::raw::c_void, + ); +} +extern "C" { + pub fn sqlite3_open( + filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_open16( + filename: *const ::std::os::raw::c_void, + ppDb: *mut *mut sqlite3, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_open_v2( + filename: *const ::std::os::raw::c_char, + ppDb: *mut *mut sqlite3, + flags: ::std::os::raw::c_int, + zVfs: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_uri_parameter( + zFilename: *const ::std::os::raw::c_char, + zParam: *const ::std::os::raw::c_char, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_extended_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_stmt { + _unused: [u8; 0], +} +extern "C" { + pub fn sqlite3_limit( + arg1: *mut sqlite3, + id: ::std::os::raw::c_int, + newVal: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_prepare( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_prepare_v2( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_char, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_prepare16( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_prepare16_v2( + db: *mut sqlite3, + zSql: *const ::std::os::raw::c_void, + nByte: ::std::os::raw::c_int, + ppStmt: *mut *mut sqlite3_stmt, + pzTail: *mut *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_sql(pStmt: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_stmt_readonly(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct Mem { + _unused: [u8; 0], +} +pub type sqlite3_value = Mem; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_context { + _unused: [u8; 0], +} +extern "C" { + pub fn sqlite3_bind_blob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_double( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: f64, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_int( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_int64( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: sqlite3_int64, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_null( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_text( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + n: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_text16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_value( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + arg3: *const sqlite3_value, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_zeroblob( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + n: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_bind_parameter_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_bind_parameter_index( + arg1: *mut sqlite3_stmt, + zName: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_name( + arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_column_name16( + arg1: *mut sqlite3_stmt, + N: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_database_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_column_database_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_table_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_column_table_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_origin_name( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_column_origin_name16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_decltype( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_column_decltype16( + arg1: *mut sqlite3_stmt, + arg2: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_blob( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_bytes( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_bytes16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64; +} +extern "C" { + pub fn sqlite3_column_int( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_int64( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_column_text( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_uchar; +} +extern "C" { + pub fn sqlite3_column_text16( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_column_type( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_column_value( + arg1: *mut sqlite3_stmt, + iCol: ::std::os::raw::c_int, + ) -> *mut sqlite3_value; +} +extern "C" { + pub fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function16( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_void, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_function_v2( + db: *mut sqlite3, + zFunctionName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + eTextRep: ::std::os::raw::c_int, + pApp: *mut ::std::os::raw::c_void, + xFunc: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xStep: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + xFinal: ::std::option::Option, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_transfer_bindings( + arg1: *mut sqlite3_stmt, + arg2: *mut sqlite3_stmt, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_global_recover() -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_thread_cleanup(); +} +extern "C" { + pub fn sqlite3_memory_alarm( + arg1: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: sqlite3_int64, + arg3: ::std::os::raw::c_int, + ), + >, + arg2: *mut ::std::os::raw::c_void, + arg3: sqlite3_int64, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64; +} +extern "C" { + pub fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar; +} +extern "C" { + pub fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_aggregate_context( + arg1: *mut sqlite3_context, + nBytes: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3; +} +extern "C" { + pub fn sqlite3_get_auxdata( + arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_set_auxdata( + arg1: *mut sqlite3_context, + N: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option, + ); +} +pub type sqlite3_destructor_type = + ::std::option::Option; +extern "C" { + pub fn sqlite3_result_blob( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64); +} +extern "C" { + pub fn sqlite3_result_error( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn sqlite3_result_error16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + ); +} +extern "C" { + pub fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context); +} +extern "C" { + pub fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context); +} +extern "C" { + pub fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite3_int64); +} +extern "C" { + pub fn sqlite3_result_null(arg1: *mut sqlite3_context); +} +extern "C" { + pub fn sqlite3_result_text( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16le( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_text16be( + arg1: *mut sqlite3_context, + arg2: *const ::std::os::raw::c_void, + arg3: ::std::os::raw::c_int, + arg4: ::std::option::Option, + ); +} +extern "C" { + pub fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value); +} +extern "C" { + pub fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, n: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_create_collation( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation_v2( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + eTextRep: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_collation16( + arg1: *mut sqlite3, + zName: *const ::std::os::raw::c_void, + eTextRep: ::std::os::raw::c_int, + pArg: *mut ::std::os::raw::c_void, + xCompare: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + arg4: ::std::os::raw::c_int, + arg5: *const ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + ), + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_collation_needed16( + arg1: *mut sqlite3, + arg2: *mut ::std::os::raw::c_void, + arg3: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + eTextRep: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_void, + ), + >, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char; +} +extern "C" { + pub fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3; +} +extern "C" { + pub fn sqlite3_next_stmt(pDb: *mut sqlite3, pStmt: *mut sqlite3_stmt) -> *mut sqlite3_stmt; +} +extern "C" { + pub fn sqlite3_commit_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_rollback_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_update_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: ::std::os::raw::c_int, + arg3: *const ::std::os::raw::c_char, + arg4: *const ::std::os::raw::c_char, + arg5: sqlite3_int64, + ), + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_soft_heap_limit64(N: sqlite3_int64) -> sqlite3_int64; +} +extern "C" { + pub fn sqlite3_soft_heap_limit(N: ::std::os::raw::c_int); +} +extern "C" { + pub fn sqlite3_table_column_metadata( + db: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + zTableName: *const ::std::os::raw::c_char, + zColumnName: *const ::std::os::raw::c_char, + pzDataType: *mut *const ::std::os::raw::c_char, + pzCollSeq: *mut *const ::std::os::raw::c_char, + pNotNull: *mut ::std::os::raw::c_int, + pPrimaryKey: *mut ::std::os::raw::c_int, + pAutoinc: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_load_extension( + db: *mut sqlite3, + zFile: *const ::std::os::raw::c_char, + zProc: *const ::std::os::raw::c_char, + pzErrMsg: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_enable_load_extension( + db: *mut sqlite3, + onoff: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_auto_extension( + xEntryPoint: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_reset_auto_extension(); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_module { + pub iVersion: ::std::os::raw::c_int, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xConnect: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + pAux: *mut ::std::os::raw::c_void, + argc: ::std::os::raw::c_int, + argv: *const *const ::std::os::raw::c_char, + ppVTab: *mut *mut sqlite3_vtab, + arg2: *mut *mut ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xBestIndex: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: *mut sqlite3_index_info, + ) -> ::std::os::raw::c_int, + >, + pub xDisconnect: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xDestroy: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xOpen: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + ppCursor: *mut *mut sqlite3_vtab_cursor, + ) -> ::std::os::raw::c_int, + >, + pub xClose: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xFilter: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + idxNum: ::std::os::raw::c_int, + idxStr: *const ::std::os::raw::c_char, + argc: ::std::os::raw::c_int, + argv: *mut *mut sqlite3_value, + ) -> ::std::os::raw::c_int, + >, + pub xNext: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xEof: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int, + >, + pub xColumn: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + arg2: *mut sqlite3_context, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRowid: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab_cursor, + pRowid: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xUpdate: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_vtab, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + arg4: *mut sqlite3_int64, + ) -> ::std::os::raw::c_int, + >, + pub xBegin: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xSync: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xCommit: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xRollback: ::std::option::Option< + unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int, + >, + pub xFindFunction: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + nArg: ::std::os::raw::c_int, + zName: *const ::std::os::raw::c_char, + pxFunc: *mut ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_context, + arg2: ::std::os::raw::c_int, + arg3: *mut *mut sqlite3_value, + ), + >, + ppArg: *mut *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int, + >, + pub xRename: ::std::option::Option< + unsafe extern "C" fn( + pVtab: *mut sqlite3_vtab, + zNew: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int, + >, + pub xSavepoint: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRelease: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pub xRollbackTo: ::std::option::Option< + unsafe extern "C" fn( + pVTab: *mut sqlite3_vtab, + arg1: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_module() { + assert_eq!( + ::std::mem::size_of::(), + 184usize, + concat!("Size of: ", stringify!(sqlite3_module)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_module)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).iVersion as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(iVersion) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xConnect as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xConnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBestIndex as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBestIndex) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDisconnect as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDisconnect) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xDestroy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xOpen as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xOpen) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xClose as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xClose) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFilter as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFilter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xNext as *const _ as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xNext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xEof as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xEof) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xColumn as *const _ as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xColumn) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRowid as *const _ as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRowid) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUpdate as *const _ as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xUpdate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xBegin as *const _ as usize }, + 112usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xBegin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSync as *const _ as usize }, + 120usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSync) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCommit as *const _ as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xCommit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollback as *const _ as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollback) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFindFunction as *const _ as usize }, + 144usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xFindFunction) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRename as *const _ as usize }, + 152usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRename) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xSavepoint as *const _ as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xSavepoint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRelease as *const _ as usize }, + 168usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRelease) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRollbackTo as *const _ as usize }, + 176usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_module), + "::", + stringify!(xRollbackTo) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info { + pub nConstraint: ::std::os::raw::c_int, + pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint, + pub nOrderBy: ::std::os::raw::c_int, + pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby, + pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage, + pub idxNum: ::std::os::raw::c_int, + pub idxStr: *mut ::std::os::raw::c_char, + pub needToFreeIdxStr: ::std::os::raw::c_int, + pub orderByConsumed: ::std::os::raw::c_int, + pub estimatedCost: f64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint { + pub iColumn: ::std::os::raw::c_int, + pub op: ::std::os::raw::c_uchar, + pub usable: ::std::os::raw::c_uchar, + pub iTermOffset: ::std::os::raw::c_int, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() { + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).op as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(op) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).usable + as *const _ as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(usable) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iTermOffset + as *const _ as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint), + "::", + stringify!(iTermOffset) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_orderby { + pub iColumn: ::std::os::raw::c_int, + pub desc: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_orderby) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).iColumn as *const _ + as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(iColumn) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).desc as *const _ + as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_orderby), + "::", + stringify!(desc) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_index_info_sqlite3_index_constraint_usage { + pub argvIndex: ::std::os::raw::c_int, + pub omit: ::std::os::raw::c_uchar, +} +#[test] +fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!( + "Size of: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).argvIndex + as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(argvIndex) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).omit + as *const _ as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info_sqlite3_index_constraint_usage), + "::", + stringify!(omit) + ) + ); +} +#[test] +fn bindgen_test_layout_sqlite3_index_info() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_index_info)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nConstraint as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aConstraint as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraint) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nOrderBy as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(nOrderBy) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aOrderBy as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aOrderBy) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).aConstraintUsage as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(aConstraintUsage) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxNum as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxNum) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).idxStr as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(idxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).needToFreeIdxStr as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(needToFreeIdxStr) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).orderByConsumed as *const _ as usize + }, + 60usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(orderByConsumed) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).estimatedCost as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_index_info), + "::", + stringify!(estimatedCost) + ) + ); +} +extern "C" { + pub fn sqlite3_create_module( + db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + p: *const sqlite3_module, + pClientData: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_create_module_v2( + db: *mut sqlite3, + zName: *const ::std::os::raw::c_char, + p: *const sqlite3_module, + pClientData: *mut ::std::os::raw::c_void, + xDestroy: ::std::option::Option, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab { + pub pModule: *const sqlite3_module, + pub nRef: ::std::os::raw::c_int, + pub zErrMsg: *mut ::std::os::raw::c_char, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab() { + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pModule as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(pModule) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nRef as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(nRef) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).zErrMsg as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab), + "::", + stringify!(zErrMsg) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_vtab_cursor { + pub pVtab: *mut sqlite3_vtab, +} +#[test] +fn bindgen_test_layout_sqlite3_vtab_cursor() { + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_vtab_cursor)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pVtab as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_vtab_cursor), + "::", + stringify!(pVtab) + ) + ); +} +extern "C" { + pub fn sqlite3_declare_vtab( + arg1: *mut sqlite3, + zSQL: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_overload_function( + arg1: *mut sqlite3, + zFuncName: *const ::std::os::raw::c_char, + nArg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_blob { + _unused: [u8; 0], +} +extern "C" { + pub fn sqlite3_blob_open( + arg1: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + zTable: *const ::std::os::raw::c_char, + zColumn: *const ::std::os::raw::c_char, + iRow: sqlite3_int64, + flags: ::std::os::raw::c_int, + ppBlob: *mut *mut sqlite3_blob, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_blob_reopen( + arg1: *mut sqlite3_blob, + arg2: sqlite3_int64, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_blob_read( + arg1: *mut sqlite3_blob, + Z: *mut ::std::os::raw::c_void, + N: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_blob_write( + arg1: *mut sqlite3_blob, + z: *const ::std::os::raw::c_void, + n: ::std::os::raw::c_int, + iOffset: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_vfs_find(zVfsName: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs; +} +extern "C" { + pub fn sqlite3_vfs_register( + arg1: *mut sqlite3_vfs, + makeDflt: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex; +} +extern "C" { + pub fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex); +} +extern "C" { + pub fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex); +} +extern "C" { + pub fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_mutex_methods { + pub xMutexInit: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexEnd: ::std::option::Option ::std::os::raw::c_int>, + pub xMutexAlloc: ::std::option::Option< + unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex, + >, + pub xMutexFree: ::std::option::Option, + pub xMutexEnter: ::std::option::Option, + pub xMutexTry: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexLeave: ::std::option::Option, + pub xMutexHeld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, + pub xMutexNotheld: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int, + >, +} +#[test] +fn bindgen_test_layout_sqlite3_mutex_methods() { + assert_eq!( + ::std::mem::size_of::(), + 72usize, + concat!("Size of: ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_mutex_methods)) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexInit as *const _ as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexInit) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexEnd as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnd) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexAlloc as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexAlloc) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexFree as *const _ as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexFree) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexEnter as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexEnter) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xMutexTry as *const _ as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexTry) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexLeave as *const _ as usize + }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexLeave) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexHeld as *const _ as usize + }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexHeld) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xMutexNotheld as *const _ as usize + }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_mutex_methods), + "::", + stringify!(xMutexNotheld) + ) + ); +} +extern "C" { + pub fn sqlite3_mutex_held(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_mutex_notheld(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex; +} +extern "C" { + pub fn sqlite3_file_control( + arg1: *mut sqlite3, + zDbName: *const ::std::os::raw::c_char, + op: ::std::os::raw::c_int, + arg2: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_test_control(op: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_status( + op: ::std::os::raw::c_int, + pCurrent: *mut ::std::os::raw::c_int, + pHighwater: *mut ::std::os::raw::c_int, + resetFlag: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_db_status( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + pCur: *mut ::std::os::raw::c_int, + pHiwtr: *mut ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_stmt_status( + arg1: *mut sqlite3_stmt, + op: ::std::os::raw::c_int, + resetFlg: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_pcache_methods { + pub pArg: *mut ::std::os::raw::c_void, + pub xInit: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int, + >, + pub xShutdown: ::std::option::Option, + pub xCreate: ::std::option::Option< + unsafe extern "C" fn( + szPage: ::std::os::raw::c_int, + bPurgeable: ::std::os::raw::c_int, + ) -> *mut sqlite3_pcache, + >, + pub xCachesize: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int), + >, + pub xPagecount: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int, + >, + pub xFetch: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + key: ::std::os::raw::c_uint, + createFlag: ::std::os::raw::c_int, + ) -> *mut ::std::os::raw::c_void, + >, + pub xUnpin: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + discard: ::std::os::raw::c_int, + ), + >, + pub xRekey: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_pcache, + arg2: *mut ::std::os::raw::c_void, + oldKey: ::std::os::raw::c_uint, + newKey: ::std::os::raw::c_uint, + ), + >, + pub xTruncate: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint), + >, + pub xDestroy: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_pcache_methods() { + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_pcache_methods)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pArg as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(pArg) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xInit as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xInit) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xShutdown as *const _ as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xShutdown) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xCreate as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCreate) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xCachesize as *const _ as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xCachesize) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xPagecount as *const _ as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xPagecount) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xFetch as *const _ as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xFetch) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xUnpin as *const _ as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xUnpin) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xRekey as *const _ as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xRekey) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).xTruncate as *const _ as usize + }, + 72usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xTruncate) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDestroy as *const _ as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_pcache_methods), + "::", + stringify!(xDestroy) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_backup { + _unused: [u8; 0], +} +extern "C" { + pub fn sqlite3_backup_init( + pDest: *mut sqlite3, + zDestName: *const ::std::os::raw::c_char, + pSource: *mut sqlite3, + zSourceName: *const ::std::os::raw::c_char, + ) -> *mut sqlite3_backup; +} +extern "C" { + pub fn sqlite3_backup_step( + p: *mut sqlite3_backup, + nPage: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_backup_finish(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_backup_remaining(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_backup_pagecount(p: *mut sqlite3_backup) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_unlock_notify( + pBlocked: *mut sqlite3, + xNotify: ::std::option::Option< + unsafe extern "C" fn( + apArg: *mut *mut ::std::os::raw::c_void, + nArg: ::std::os::raw::c_int, + ), + >, + pNotifyArg: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_strnicmp( + arg1: *const ::std::os::raw::c_char, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_log( + iErrCode: ::std::os::raw::c_int, + zFormat: *const ::std::os::raw::c_char, + ... + ); +} +extern "C" { + pub fn sqlite3_wal_hook( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *mut sqlite3, + arg3: *const ::std::os::raw::c_char, + arg4: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + arg3: *mut ::std::os::raw::c_void, + ) -> *mut ::std::os::raw::c_void; +} +extern "C" { + pub fn sqlite3_wal_autocheckpoint( + db: *mut sqlite3, + N: ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_wal_checkpoint( + db: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_wal_checkpoint_v2( + db: *mut sqlite3, + zDb: *const ::std::os::raw::c_char, + eMode: ::std::os::raw::c_int, + pnLog: *mut ::std::os::raw::c_int, + pnCkpt: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_vtab_config( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, + ... + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn sqlite3_rtree_geometry_callback( + db: *mut sqlite3, + zGeom: *const ::std::os::raw::c_char, + xGeom: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3_rtree_geometry, + nCoord: ::std::os::raw::c_int, + aCoord: *mut f64, + pRes: *mut ::std::os::raw::c_int, + ) -> ::std::os::raw::c_int, + >, + pContext: *mut ::std::os::raw::c_void, + ) -> ::std::os::raw::c_int; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct sqlite3_rtree_geometry { + pub pContext: *mut ::std::os::raw::c_void, + pub nParam: ::std::os::raw::c_int, + pub aParam: *mut f64, + pub pUser: *mut ::std::os::raw::c_void, + pub xDelUser: ::std::option::Option, +} +#[test] +fn bindgen_test_layout_sqlite3_rtree_geometry() { + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(sqlite3_rtree_geometry)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pContext as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pContext) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).nParam as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(nParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).aParam as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(aParam) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).pUser as *const _ as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(pUser) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).xDelUser as *const _ as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_rtree_geometry), + "::", + stringify!(xDelUser) + ) + ); +} +pub type __builtin_va_list = [__va_list_tag; 1usize]; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct __va_list_tag { + pub gp_offset: ::std::os::raw::c_uint, + pub fp_offset: ::std::os::raw::c_uint, + pub overflow_arg_area: *mut ::std::os::raw::c_void, + pub reg_save_area: *mut ::std::os::raw::c_void, +} +#[test] +fn bindgen_test_layout___va_list_tag() { + assert_eq!( + ::std::mem::size_of::<__va_list_tag>(), + 24usize, + concat!("Size of: ", stringify!(__va_list_tag)) + ); + assert_eq!( + ::std::mem::align_of::<__va_list_tag>(), + 8usize, + concat!("Alignment of ", stringify!(__va_list_tag)) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(gp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(fp_offset) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(overflow_arg_area) + ) + ); + assert_eq!( + unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(__va_list_tag), + "::", + stringify!(reg_save_area) + ) + ); +} diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index 85a49c1a6..d531c96c9 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -20,20 +20,23 @@ fn main() { "cargo:warning=Builds with bundled SQLCipher are not supported. Searching for SQLCipher to link against. \ This can lead to issues if your version of SQLCipher is not up to date!"); } + build_linked::main(&out_dir, &out_path); + return; + } + if cfg!(feature = "loadable_extension") { + build_loadable_extension::main(&out_dir, &out_path); + return; + } + + // This can't be `cfg!` without always requiring our `mod build_bundled` (and + // thus `cc`) + #[cfg(any(feature = "bundled", all(windows, feature = "bundled-windows")))] + { + build_bundled::main(&out_dir, &out_path) + } + #[cfg(not(any(feature = "bundled", all(windows, feature = "bundled-windows"))))] + { build_linked::main(&out_dir, &out_path) - } else if cfg!(feature = "loadable_extension") { - build_loadable_extension::main(&out_dir, &out_path) - } else { - // This can't be `cfg!` without always requiring our `mod build_bundled` (and - // thus `cc`) - #[cfg(any(feature = "bundled", all(windows, feature = "bundled-windows")))] - { - build_bundled::main(&out_dir, &out_path) - } - #[cfg(not(any(feature = "bundled", all(windows, feature = "bundled-windows"))))] - { - build_linked::main(&out_dir, &out_path) - } } } @@ -51,14 +54,17 @@ mod build_bundled { #[cfg(feature = "buildtime_bindgen")] { use super::{bindings, header_file, HeaderLocation}; - let header = HeaderLocation::FromPath(format!("sqlite3/{}", header_file())); + let header_path = format!("sqlite3/{}", header_file()); + let header = HeaderLocation::FromPath(header_path.to_owned()); bindings::write_to_out_dir(header, out_path); + println!("cargo:rerun-if-changed={}", header_path); } #[cfg(not(feature = "buildtime_bindgen"))] { use std::fs; fs::copy("sqlite3/bindgen_bundled_version.rs", out_path) .expect("Could not copy bindings to output directory"); + println!("cargo:rerun-if-changed=sqlite3/bindgen_bundled_version.rs"); } println!("cargo:rerun-if-changed=sqlite3/sqlite3.c"); println!("cargo:rerun-if-changed=sqlite3/wasm32-wasi-vfs.c"); @@ -200,7 +206,7 @@ impl From for String { prefix, prefix ) }); - header.push_str("/"); + header.push('/'); header.push_str(header_file()); header } @@ -211,13 +217,32 @@ impl From for String { } mod build_linked { + #[cfg(all(feature = "vcpkg", target_env = "msvc"))] + extern crate vcpkg; + use super::{bindings, env_prefix, header_file, HeaderLocation}; use std::env; use std::path::Path; pub fn main(_out_dir: &str, out_path: &Path) { let header = find_sqlite(); - bindings::write_to_out_dir(header, out_path); + if cfg!(any( + feature = "bundled_bindings", + feature = "bundled", + all(windows, feature = "bundled-windows") + )) && !cfg!(feature = "buildtime_bindgen") + { + // Generally means the `bundled_bindings` feature is enabled + // (there's also an edge case where we get here involving + // sqlcipher). In either case most users are better off with turning + // on buildtime_bindgen instead, but this is still supported as we + // have runtime version checks and there are good reasons to not + // want to run bindgen. + std::fs::copy("sqlite3/bindgen_bundled_version.rs", out_path) + .expect("Could not copy bindings to output directory"); + } else { + bindings::write_to_out_dir(header, out_path); + } } fn find_link_mode() -> &'static str { @@ -326,6 +351,9 @@ mod build_loadable_extension { pub fn main(_out_dir: &str, out_path: &Path) { let header = find_sqlite(); + if cfg!(feature = "session") { + panic!("The session feature is not available when building a loadable extension since the sqlite API routines for loadable extensions do not include session methods"); + } bindings::write_to_out_dir(header, out_path); } @@ -395,6 +423,10 @@ mod bindings { static PREBUILT_BINDGEN_PATHS: &[&str] = &[ "bindgen-bindings/bindgen_3.6.8", + #[cfg(feature = "min_sqlite_version_3_6_23")] + "bindgen-bindings/bindgen_3.6.23", + #[cfg(feature = "min_sqlite_version_3_7_7")] + "bindgen-bindings/bindgen_3.7.7", #[cfg(feature = "min_sqlite_version_3_7_16")] "bindgen-bindings/bindgen_3.7.16", #[cfg(any( @@ -462,6 +494,8 @@ mod bindings { pub fn write_to_out_dir(header: HeaderLocation, out_path: &Path) { let header: String = header.into(); let mut output = Vec::new(); + println!("cargo:rerun-if-env-changed=SQLITE3_INCLUDE_DIR"); + println!("cargo:rerun-if-env-changed=SQLITE3_LIB_DIR"); let mut bindings = bindgen::builder() .header(header.clone()) .parse_callbacks(Box::new(SqliteTypeChooser)) @@ -520,21 +554,37 @@ mod bindings { let target_arch = std::env::var("TARGET").unwrap(); let host_arch = std::env::var("HOST").unwrap(); let is_cross_compiling = target_arch != host_arch; - + let blacklist_va_list_functions = &vec![ + "sqlite3_vmprintf", + "sqlite3_vsnprintf", + "sqlite3_xvsnprintf", + "sqlite3_str_vappendf", + ]; // Note that when generating the bundled file, we're essentially always // cross compiling. - #[cfg(not(feature = "loadable_extension"))] if generating_bundled_bindings() || is_cross_compiling { - // Get rid of va_list, as it's not + // get rid of blacklisted functions that use va_list + for fn_name in blacklist_va_list_functions { + bindings = bindings.blacklist_function(fn_name) + } + // Get rid of va_list bindings = bindings - .blacklist_function("sqlite3_vmprintf") - .blacklist_function("sqlite3_vsnprintf") - .blacklist_function("sqlite3_str_vappendf") .blacklist_type("va_list") .blacklist_type("__builtin_va_list") .blacklist_type("__gnuc_va_list") - .blacklist_type("__va_list_tag") .blacklist_item("__GNUC_VA_LIST"); + + // handle __va_list_tag specially as it is referenced from sqlite3_api_routines + // so if it is blacklisted, those references will be broken. + // when building as a loadable_extension, make __va_list_tag opaque instead of omitting it + #[cfg(not(feature = "loadable_extension"))] + { + bindings = bindings.blacklist_type("__va_list_tag"); + } + #[cfg(feature = "loadable_extension")] + { + bindings = bindings.opaque_type("__va_list_tag"); + } } // rust-bindgen does not handle CPP macros that alias functions, so @@ -555,7 +605,7 @@ mod bindings { // if an attempt is made to call an extern function that we know won't exist // and to avoid undefined symbol issues when linking the loadable extension // rust code with other (e.g. non-rust) code - bindings = bindings.blacklist_function(".*"); + bindings = bindings.blacklist_function(".*") } bindings @@ -563,7 +613,9 @@ mod bindings { .unwrap_or_else(|_| panic!("could not run bindgen on header {}", header)) .write(Box::new(&mut output)) .expect("could not write output of bindgen"); - let mut output = String::from_utf8(output).expect("bindgen output was not UTF-8?!"); + + #[allow(unused_mut)] + let mut output_string = String::from_utf8(output).expect("bindgen output was not UTF-8?!"); // Get the list of API functions supported by sqlite3_api_routines, // set the corresponding sqlite3 api routine to be blacklisted in the @@ -577,34 +629,27 @@ mod bindings { { let api_routines_struct_name = "sqlite3_api_routines".to_owned(); - let api_routines_struct = match get_struct_by_name(&output, &api_routines_struct_name) { - Some(s) => s, - None => { - panic!( - "Failed to find struct {} in early bindgen output", - api_routines_struct_name - ); - } - }; + let api_routines_struct = + match get_struct_by_name(&output_string, &api_routines_struct_name) { + Some(s) => s, + None => { + panic!( + "Failed to find struct {} in early bindgen output", + &api_routines_struct_name + ); + } + }; - #[cfg(feature = "loadable_extension")] - { - output.push_str( - r#" + output_string.push_str( + r#" // sqlite3_api is defined in lib.rs as either a static or an extern when compiled as a loadable_extension -#[cfg(feature = "loadable_extension")] use crate::sqlite3_api; -"#, - ); - } - - output.push_str( - r" // sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) -"); +"#, + ); // create wrapper for each field in api routines struct for field in &api_routines_struct.fields { @@ -619,14 +664,24 @@ use crate::sqlite3_api; // construct global sqlite api function identifier from field identifier let api_fn_name = format!("sqlite3_{}", ident); + if (generating_bundled_bindings() || is_cross_compiling) + && blacklist_va_list_functions + .iter() + .any(|fn_name| *fn_name == api_fn_name) + { + // skip this function as it is blacklisted when generating bundled bindings or cross compiling + continue; + } + // generate wrapper function and push it to output string let wrapper = generate_wrapper(ident, field_type, &api_fn_name); - output.push_str(&wrapper); + output_string.push_str(&wrapper); } - output.push_str("\n"); + output_string.push('\n'); } + #[allow(unused_mut)] let mut file = OpenOptions::new() .write(true) .truncate(true) @@ -634,8 +689,65 @@ use crate::sqlite3_api; .open(out_path) .unwrap_or_else(|_| panic!("Could not write to {:?}", out_path)); - file.write_all(output.as_bytes()) + #[cfg(not(feature = "loadable_extension"))] + // the generated bindings have already been through rustfmt, just write them out + file.write_all(output_string.as_bytes()) .unwrap_or_else(|_| panic!("Could not write to {:?}", out_path)); + #[cfg(feature = "loadable_extension")] + write_with_rustfmt(file, output_string) // if we have generated loadable_extension bindings, pipe them through rustfmt as we write them out + .unwrap_or_else(|e| panic!("Could not rustfmt output to {:?}: {:?}", out_path, e)); + } + + #[cfg(feature = "loadable_extension")] + fn write_with_rustfmt(mut file: std::fs::File, output: String) -> Result<(), String> { + // pipe generated bindings through rustfmt + let rustfmt = + which::which("rustfmt").map_err(|e| format!("rustfmt not on PATH: {:?}", e))?; + let mut cmd = std::process::Command::new(rustfmt); + cmd.stdin(std::process::Stdio::piped()) + .stdout(std::process::Stdio::piped()); + let mut rustfmt_child = cmd + .spawn() + .map_err(|e| format!("failed to execute rustfmt: {:?}", e))?; + let mut rustfmt_child_stdin = rustfmt_child + .stdin + .take() + .ok_or("failed to take rustfmt stdin")?; + let mut rustfmt_child_stdout = rustfmt_child + .stdout + .take() + .ok_or("failed to take rustfmt stdout")?; + + // spawn a thread to write output string to rustfmt stdin + let stdin_handle = ::std::thread::spawn(move || { + let _ = rustfmt_child_stdin.write_all(output.as_bytes()); + output + }); + + // read stdout of rustfmt and write it to bindings file at out_path + std::io::copy(&mut rustfmt_child_stdout, &mut file) + .map_err(|e| format!("failed to write to rustfmt stdin: {:?}", e))?; + + let status = rustfmt_child + .wait() + .map_err(|e| format!("failed to wait for rustfmt to complete: {:?}", e))?; + stdin_handle + .join() + .map_err(|e| format!("unexpected error: failed to join rustfmt stdin: {:?}", e))?; + + match status.code() { + Some(0) => {} + Some(2) => { + return Err("rustfmt parsing error".to_string()); + } + Some(3) => { + return Err("rustfmt could not format some lines.".to_string()); + } + _ => { + return Err("Internal rustfmt error".to_string()); + } + } + Ok(()) } #[cfg(feature = "loadable_extension")] @@ -689,6 +801,25 @@ use crate::sqlite3_api; panic!("unexpected failure to parse bare function"); } + #[cfg(feature = "loadable_extension")] + fn generate_varargs_input_idents( + field_ident: &syn::Ident, + bare_fn: &syn::TypeBareFn, + var_arg_types: &[&syn::Type], + ) -> syn::punctuated::Punctuated { + use syn::Token; + let mut api_fn_inputs = bare_fn.inputs.clone(); + for (index, var_arg_type) in var_arg_types.iter().enumerate() { + let mut input = api_fn_inputs[api_fn_inputs.len() - 1].clone(); + let input_ident = syn::Ident::new(&format!("vararg{}", index + 1), field_ident.span()); + let colon = Token![:](field_ident.span()); + input.name = Some((input_ident, colon)); + input.ty = (*var_arg_type).to_owned(); + api_fn_inputs.push(input); + } + api_fn_inputs + } + #[cfg(feature = "loadable_extension")] fn generate_wrapper( field_ident: &syn::Ident, @@ -696,69 +827,105 @@ use crate::sqlite3_api; api_fn_name: &str, ) -> String { use quote::quote; - use syn::Token; + use std::collections::BTreeMap; let field_name = field_ident.to_string(); - let api_fn_ident = syn::Ident::new(&api_fn_name, field_ident.span()); // add wrapper macro invocation to be appended to the generated bindings let bare_fn = bare_fn_from_type_path(syn_type); let api_fn_output = &bare_fn.output; - // prepare inputs - let mut api_fn_inputs = bare_fn.inputs.clone(); + // a map of wrapper function names to function inputs vectors + let mut wrapper_fn_inputs_map: BTreeMap< + String, + syn::punctuated::Punctuated, + > = BTreeMap::new(); - // handle variadic api functions + // always generate a wrapper function of the same name as the api function name with no variadic arguments + wrapper_fn_inputs_map.insert( + api_fn_name.to_string(), + generate_varargs_input_idents(field_ident, &bare_fn, &[]), + ); + + // handle variadic api functions by generating additional bindings for specific sets of method arguments that we support if bare_fn.variadic.is_some() { + let const_c_char_type: syn::Type = syn::parse2(quote!(*const ::std::os::raw::c_char)) + .expect("failed to parse c_char type"); + let mut_void_type: syn::Type = + syn::parse2(quote!(*mut ::core::ffi::c_void)).expect("failed to parse c_char type"); + let c_int_type: syn::Type = + syn::parse2(quote!(::std::os::raw::c_int)).expect("failed to parse c_int type"); + let mut_c_int_type: syn::Type = syn::parse2(quote!(*mut ::std::os::raw::c_int)) + .expect("failed to parse mutable c_int reference"); // until rust c_variadic support exists, we can't // transparently wrap variadic api functions. // generate specific set of args in place of // variadic for each function we care about. - let var_arg_types: Vec> = match api_fn_name { + // functions we don't handle will have + match api_fn_name { "sqlite3_db_config" => { - let mut_int_type: syn::TypeReference = syn::parse2(quote!(&mut i32)) - .expect("failed to parse mutable integer reference"); - vec![None, Some(syn::Type::Reference(mut_int_type))] + // https://sqlite.org/c3ref/c_dbconfig_defensive.html + wrapper_fn_inputs_map.insert( + "sqlite3_db_config_constchar".to_string(), + generate_varargs_input_idents(field_ident, &bare_fn, &[&const_c_char_type]), + ); // used for SQLITE_DBCONFIG_MAINDBNAME + wrapper_fn_inputs_map.insert( + "sqlite3_db_config_void_int_mutint".to_string(), + generate_varargs_input_idents( + field_ident, + &bare_fn, + &[&mut_void_type, &c_int_type, &mut_c_int_type], + ), + ); // used for SQLITE_DBCONFIG_LOOKASIDE + wrapper_fn_inputs_map.insert( + "sqlite3_db_config_int_mutint".to_string(), + generate_varargs_input_idents( + field_ident, + &bare_fn, + &[&c_int_type, &mut_c_int_type], + ), + ); // used for all other configuration verbs } - _ => vec![None], - }; - - for (index, var_arg_type) in var_arg_types.iter().enumerate() { - let mut input = api_fn_inputs[api_fn_inputs.len() - 1].clone(); - let input_ident = - syn::Ident::new(&format!("vararg{}", index + 1), field_ident.span()); - let colon = Token![:](field_ident.span()); - input.name = Some((input_ident, colon)); - if let Some(t) = var_arg_type.to_owned() { - input.ty = t; + "sqlite3_vtab_config" => { + // https://sqlite.org/c3ref/c_vtab_constraint_support.html + wrapper_fn_inputs_map.insert( + "sqlite3_vtab_config_int".to_string(), + generate_varargs_input_idents(field_ident, &bare_fn, &[&c_int_type]), + ); // used for SQLITE_VTAB_CONSTRAINT_SUPPORT } - api_fn_inputs.push(input); - } + _ => {} + }; } - // get identifiers for each of the inputs to use in the api call - let api_fn_input_idents: Vec = (&api_fn_inputs) - .into_iter() - .map(|input| match &input.name { - Some((ident, _)) => ident.to_owned(), - _ => { - panic!("Input has no name {:#?}", input); - } - }) - .collect(); - - // generate wrapper and return it as a string - let wrapper_tokens = quote! { - pub unsafe fn #api_fn_ident(#api_fn_inputs) #api_fn_output { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let mut wrappers = String::new(); + for (api_fn_name, api_fn_inputs) in wrapper_fn_inputs_map { + let api_fn_ident = syn::Ident::new(&api_fn_name, field_ident.span()); + + // get identifiers for each of the inputs to use in the api call + let api_fn_input_idents: Vec = (&api_fn_inputs) + .into_iter() + .map(|input| match &input.name { + Some((ident, _)) => ident.to_owned(), + _ => { + panic!("Input has no name {:#?}", input); + } + }) + .collect(); + + // generate wrapper and return it as a string + let wrapper_tokens = quote! { + pub unsafe fn #api_fn_ident(#api_fn_inputs) #api_fn_output { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).#field_ident + .expect(stringify!("sqlite3_api contains null pointer for ", #field_name, " function")))( + #(#api_fn_input_idents),* + ) } - ((*sqlite3_api).#field_ident - .expect(stringify!("sqlite3_api contains null pointer for ", #field_name, " function")))( - #(#api_fn_input_idents),* - ) - } - }; - return format!("{}\n\n", wrapper_tokens.to_string()); + }; + wrappers.push_str(&format!("{}\n\n", wrapper_tokens.to_string())); + } + wrappers } } diff --git a/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs b/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs index df7bfaf36..32bd9484a 100644 --- a/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs +++ b/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs @@ -1,6 +1,5 @@ -/* automatically generated by rust-bindgen 0.56.0 */ +/* automatically generated by rust-bindgen 0.57.0 */ -pub const __GNUC_VA_LIST: i32 = 1; pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.34.0\0"; pub const SQLITE_VERSION_NUMBER: i32 = 3034000; pub const SQLITE_SOURCE_ID: &'static [u8; 85usize] = @@ -449,8 +448,6 @@ pub const FTS5_TOKENIZE_PREFIX: i32 = 2; pub const FTS5_TOKENIZE_DOCUMENT: i32 = 4; pub const FTS5_TOKENIZE_AUX: i32 = 8; pub const FTS5_TOKEN_COLOCATED: i32 = 1; -pub type va_list = __builtin_va_list; -pub type __gnuc_va_list = __builtin_va_list; extern "C" { pub static mut sqlite3_version: [::std::os::raw::c_char; 0usize]; } @@ -7911,14 +7908,11 @@ pub type sqlite3_loadext_entry = ::std::option::Option< pThunk: *const sqlite3_api_routines, ) -> ::std::os::raw::c_int, >; -pub type __builtin_va_list = [__va_list_tag; 1usize]; #[repr(C)] +#[repr(align(8))] #[derive(Debug, Copy, Clone)] pub struct __va_list_tag { - pub gp_offset: ::std::os::raw::c_uint, - pub fp_offset: ::std::os::raw::c_uint, - pub overflow_arg_area: *mut ::std::os::raw::c_void, - pub reg_save_area: *mut ::std::os::raw::c_void, + pub _bindgen_opaque_blob: [u64; 3usize], } #[test] fn bindgen_test_layout___va_list_tag() { @@ -7932,50 +7926,9 @@ fn bindgen_test_layout___va_list_tag() { 8usize, concat!("Alignment of ", stringify!(__va_list_tag)) ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(gp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(fp_offset) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(overflow_arg_area) - ) - ); - assert_eq!( - unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(__va_list_tag), - "::", - stringify!(reg_save_area) - ) - ); } // sqlite3_api is defined in lib.rs as either a static or an extern when compiled as a loadable_extension -#[cfg(feature = "loadable_extension")] use crate::sqlite3_api; // sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) @@ -8976,10 +8929,7 @@ pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw )))(arg1) } -pub unsafe fn sqlite3_mprintf( - arg1: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) -> *mut ::std::os::raw::c_char { +pub unsafe fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char { if sqlite3_api.is_null() { panic!("sqlite3_api is null"); } @@ -8987,7 +8937,7 @@ pub unsafe fn sqlite3_mprintf( "sqlite3_api contains null pointer for ", "mprintf", " function" - )))(arg1, vararg1) + )))(arg1) } pub unsafe fn sqlite3_open( @@ -9340,7 +9290,6 @@ pub unsafe fn sqlite3_xsnprintf( arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_char, arg3: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, ) -> *mut ::std::os::raw::c_char { if sqlite3_api.is_null() { panic!("sqlite3_api is null"); @@ -9349,7 +9298,7 @@ pub unsafe fn sqlite3_xsnprintf( "sqlite3_api contains null pointer for ", "xsnprintf", " function" - )))(arg1, arg2, arg3, vararg1) + )))(arg1, arg2, arg3) } pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { @@ -9606,20 +9555,6 @@ pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_ )))(arg1) } -pub unsafe fn sqlite3_vmprintf( - arg1: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vmprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "vmprintf", - " function" - )))(arg1, arg2) -} - pub unsafe fn sqlite3_overload_function( arg1: *mut sqlite3, zFuncName: *const ::std::os::raw::c_char, @@ -10044,10 +9979,7 @@ pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std: )))(arg1, arg2) } -pub unsafe fn sqlite3_test_control( - arg1: ::std::os::raw::c_int, - vararg1: ::std::os::raw::c_int, -) -> ::std::os::raw::c_int { +pub unsafe fn sqlite3_test_control(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { if sqlite3_api.is_null() { panic!("sqlite3_api is null"); } @@ -10055,7 +9987,7 @@ pub unsafe fn sqlite3_test_control( "sqlite3_api contains null pointer for ", "test_control", " function" - )))(arg1, vararg1) + )))(arg1) } pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { @@ -10272,8 +10204,37 @@ pub unsafe fn sqlite3_create_function_v2( pub unsafe fn sqlite3_db_config( arg1: *mut sqlite3, arg2: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_config", + " function" + )))(arg1, arg2) +} + +pub unsafe fn sqlite3_db_config_constchar( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + vararg1: *const ::std::os::raw::c_char, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_config", + " function" + )))(arg1, arg2, vararg1) +} + +pub unsafe fn sqlite3_db_config_int_mutint( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, vararg1: ::std::os::raw::c_int, - vararg2: &mut i32, + vararg2: *mut ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { if sqlite3_api.is_null() { panic!("sqlite3_api is null"); @@ -10285,6 +10246,23 @@ pub unsafe fn sqlite3_db_config( )))(arg1, arg2, vararg1, vararg2) } +pub unsafe fn sqlite3_db_config_void_int_mutint( + arg1: *mut sqlite3, + arg2: ::std::os::raw::c_int, + vararg1: *mut ::core::ffi::c_void, + vararg2: ::std::os::raw::c_int, + vararg3: *mut ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).db_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "db_config", + " function" + )))(arg1, arg2, vararg1, vararg2, vararg3) +} + pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { if sqlite3_api.is_null() { panic!("sqlite3_api is null"); @@ -10324,11 +10302,7 @@ pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_ )))(arg1) } -pub unsafe fn sqlite3_log( - arg1: ::std::os::raw::c_int, - arg2: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) { +pub unsafe fn sqlite3_log(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char) { if sqlite3_api.is_null() { panic!("sqlite3_api is null"); } @@ -10336,7 +10310,7 @@ pub unsafe fn sqlite3_log( "sqlite3_api contains null pointer for ", "log", " function" - )))(arg1, arg2, vararg1) + )))(arg1, arg2) } pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { @@ -10475,6 +10449,20 @@ pub unsafe fn sqlite3_blob_reopen( pub unsafe fn sqlite3_vtab_config( arg1: *mut sqlite3, op: ::std::os::raw::c_int, +) -> ::std::os::raw::c_int { + if sqlite3_api.is_null() { + panic!("sqlite3_api is null"); + } + ((*sqlite3_api).vtab_config.expect(stringify!( + "sqlite3_api contains null pointer for ", + "vtab_config", + " function" + )))(arg1, op) +} + +pub unsafe fn sqlite3_vtab_config_int( + arg1: *mut sqlite3, + op: ::std::os::raw::c_int, vararg1: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { if sqlite3_api.is_null() { @@ -10639,22 +10627,6 @@ pub unsafe fn sqlite3_uri_parameter( )))(arg1, arg2) } -pub unsafe fn sqlite3_xvsnprintf( - arg1: ::std::os::raw::c_int, - arg2: *mut ::std::os::raw::c_char, - arg3: *const ::std::os::raw::c_char, - arg4: *mut __va_list_tag, -) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).xvsnprintf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "xvsnprintf", - " function" - )))(arg1, arg2, arg3, arg4) -} - pub unsafe fn sqlite3_wal_checkpoint_v2( arg1: *mut sqlite3, arg2: *const ::std::os::raw::c_char, @@ -11195,11 +11167,7 @@ pub unsafe fn sqlite3_str_finish(arg1: *mut sqlite3_str) -> *mut ::std::os::raw: )))(arg1) } -pub unsafe fn sqlite3_str_appendf( - arg1: *mut sqlite3_str, - zFormat: *const ::std::os::raw::c_char, - vararg1: *const ::std::os::raw::c_char, -) { +pub unsafe fn sqlite3_str_appendf(arg1: *mut sqlite3_str, zFormat: *const ::std::os::raw::c_char) { if sqlite3_api.is_null() { panic!("sqlite3_api is null"); } @@ -11207,22 +11175,7 @@ pub unsafe fn sqlite3_str_appendf( "sqlite3_api contains null pointer for ", "str_appendf", " function" - )))(arg1, zFormat, vararg1) -} - -pub unsafe fn sqlite3_str_vappendf( - arg1: *mut sqlite3_str, - zFormat: *const ::std::os::raw::c_char, - arg2: *mut __va_list_tag, -) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).str_vappendf.expect(stringify!( - "sqlite3_api contains null pointer for ", - "str_vappendf", - " function" - )))(arg1, zFormat, arg2) + )))(arg1, zFormat) } pub unsafe fn sqlite3_str_append( diff --git a/libsqlite3-sys/sqlite3/bindgen_bundled_version.rs b/libsqlite3-sys/sqlite3/bindgen_bundled_version.rs index dfcdff972..c81044664 100644 --- a/libsqlite3-sys/sqlite3/bindgen_bundled_version.rs +++ b/libsqlite3-sys/sqlite3/bindgen_bundled_version.rs @@ -1,4 +1,4 @@ -/* automatically generated by rust-bindgen 0.56.0 */ +/* automatically generated by rust-bindgen 0.57.0 */ pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.34.0\0"; pub const SQLITE_VERSION_NUMBER: i32 = 3034000; diff --git a/libsqlite3-sys/src/lib.rs b/libsqlite3-sys/src/lib.rs index a4720486d..97c785672 100644 --- a/libsqlite3-sys/src/lib.rs +++ b/libsqlite3-sys/src/lib.rs @@ -55,7 +55,6 @@ pub enum Limit { // define sqlite3_api as an extern since this code will be embedded // within a loadable extension that defines and exports this itself extern "C" { - #[no_mangle] pub static mut sqlite3_api: *mut sqlite3_api_routines; } diff --git a/libsqlite3-sys/upgrade.sh b/libsqlite3-sys/upgrade.sh index 9d41cba56..56d6d9b4a 100755 --- a/libsqlite3-sys/upgrade.sh +++ b/libsqlite3-sys/upgrade.sh @@ -4,18 +4,19 @@ SCRIPT_DIR=$(cd "$(dirname "$_")" && pwd) TARGET_DIR="$SCRIPT_DIR/../target" # ensure target dir is deterministic echo "$SCRIPT_DIR" cd "$SCRIPT_DIR" || { echo "fatal error"; exit 1; } + export SQLITE3_LIB_DIR=$SCRIPT_DIR/sqlite3 export SQLITE3_INCLUDE_DIR=$SQLITE3_LIB_DIR # Download and extract amalgamation SQLITE=sqlite-amalgamation-3340000 -curl -O https://sqlite.org/2020/$SQLITE.zip +curl -sSf -O "https://sqlite.org/2020/$SQLITE.zip" unzip -p "$SQLITE.zip" "$SQLITE/sqlite3.c" > "$SQLITE3_LIB_DIR/sqlite3.c" unzip -p "$SQLITE.zip" "$SQLITE/sqlite3.h" > "$SQLITE3_LIB_DIR/sqlite3.h" unzip -p "$SQLITE.zip" "$SQLITE/sqlite3ext.h" > "$SQLITE3_LIB_DIR/sqlite3ext.h" rm -f "$SQLITE.zip" -# Regenerate bindgen file +# Prepare to regenerate bindgen files cargo update function generate_bindgen_binding() { @@ -28,9 +29,10 @@ function generate_bindgen_binding() { env LIBSQLITE3_SYS_BUNDLING=1 cargo build --target-dir "$TARGET_DIR" --features "$features" --no-default-features find "$TARGET_DIR" -type f -name bindgen.rs -exec cp {} "$target_file" \; # rerun rustfmt after (possibly) adding wrappers - rustfmt $target_file + rustfmt "$target_file" } +# Regenerate bindgen files generate_bindgen_binding "buildtime_bindgen" "$SQLITE3_LIB_DIR/bindgen_bundled_version.rs" generate_bindgen_binding "buildtime_bindgen,loadable_extension" "$SQLITE3_LIB_DIR/bindgen_bundled_version-ext.rs" @@ -38,5 +40,5 @@ generate_bindgen_binding "buildtime_bindgen,loadable_extension" "$SQLITE3_LIB_DI cd "$SCRIPT_DIR/.." || { echo "fatal error"; exit 1; } cargo update cargo test --features "backup blob chrono functions limits load_extension serde_json trace vtab bundled" -# TODO check loadable_extension / loadable_extension_embedded + echo 'You should increment the version in libsqlite3-sys/Cargo.toml' diff --git a/src/cache.rs b/src/cache.rs index ea00019d5..03471745b 100644 --- a/src/cache.rs +++ b/src/cache.rs @@ -18,13 +18,13 @@ impl Connection { /// fn insert_new_people(conn: &Connection) -> Result<()> { /// { /// let mut stmt = conn.prepare_cached("INSERT INTO People (name) VALUES (?)")?; - /// stmt.execute(&["Joe Smith"])?; + /// stmt.execute(["Joe Smith"])?; /// } /// { /// // This will return the same underlying SQLite statement handle without /// // having to prepare it again. /// let mut stmt = conn.prepare_cached("INSERT INTO People (name) VALUES (?)")?; - /// stmt.execute(&["Bob Jones"])?; + /// stmt.execute(["Bob Jones"])?; /// } /// Ok(()) /// } diff --git a/src/config.rs b/src/config.rs index fab8bbc58..553eb601a 100644 --- a/src/config.rs +++ b/src/config.rs @@ -79,12 +79,20 @@ impl Connection { let c = self.db.borrow(); unsafe { let mut val = 0; + #[cfg(not(feature = "loadable_extension"))] check!(ffi::sqlite3_db_config( c.db(), config as c_int, -1, &mut val )); + #[cfg(feature = "loadable_extension")] + check!(ffi::sqlite3_db_config_int_mutint( + c.db(), + config as c_int, + -1, + &mut val + )); Ok(val != 0) } } @@ -108,12 +116,20 @@ impl Connection { let c = self.db.borrow_mut(); unsafe { let mut val = 0; + #[cfg(not(feature = "loadable_extension"))] check!(ffi::sqlite3_db_config( c.db(), config as c_int, if new_val { 1 } else { 0 }, &mut val )); + #[cfg(feature = "loadable_extension")] + check!(ffi::sqlite3_db_config_int_mutint( + c.db(), + config as c_int, + if new_val { 1 } else { 0 }, + &mut val + )); Ok(val != 0) } } diff --git a/src/error.rs b/src/error.rs index 148402bc8..1da8d2e2a 100644 --- a/src/error.rs +++ b/src/error.rs @@ -345,19 +345,6 @@ pub unsafe fn error_from_handle(db: *mut ffi::sqlite3, code: c_int) -> Error { error_from_sqlite_code(code, message) } -/// Check SQLite method call. -/// ```rust,ignore -/// # use rusqlite::{self, ffi, Result}; -/// fn xyz() -> Result<()> { -/// -/// unsafe { -/// // returns an Error if sqlite3_initialize fails -/// rusqlite::check!(ffi::sqlite3_initialize()); -/// } -/// Ok(()) -/// } -/// ``` -#[macro_export] macro_rules! check { ($funcall:expr) => {{ let rc = $funcall; @@ -370,25 +357,19 @@ macro_rules! check { /// Transform Rust error to SQLite error (message and code). /// # Safety /// This function is unsafe because it uses raw pointer -#[cfg(any( - feature = "vtab", - feature = "loadable_extension", - feature = "loadable_extension_embedded" -))] pub unsafe fn to_sqlite_error( e: &Error, err_msg: *mut *mut std::os::raw::c_char, ) -> std::os::raw::c_int { - use crate::util::alloc; match e { Error::SqliteFailure(err, s) => { if let Some(s) = s { - *err_msg = alloc(&s); + *err_msg = crate::util::SqliteMallocString::from_str(&s).into_raw(); } err.extended_code } err => { - *err_msg = alloc(&err.to_string()); + *err_msg = crate::util::SqliteMallocString::from_str(&err.to_string()).into_raw(); ffi::SQLITE_ERROR } } diff --git a/src/inner_connection.rs b/src/inner_connection.rs index db2eddf36..4311f84f2 100644 --- a/src/inner_connection.rs +++ b/src/inner_connection.rs @@ -368,11 +368,7 @@ rusqlite was built against SQLite {} but the runtime SQLite version is {}. To fi }); } -#[cfg(not(any( - target_arch = "wasm32", - feature = "loadable_extension", - feature = "loadable_extension_embedded", -)))] +#[cfg(not(any(target_arch = "wasm32", feature = "loadable_extension",)))] static SQLITE_INIT: std::sync::Once = std::sync::Once::new(); pub static BYPASS_SQLITE_INIT: AtomicBool = AtomicBool::new(false); @@ -380,23 +376,16 @@ pub static BYPASS_SQLITE_INIT: AtomicBool = AtomicBool::new(false); // threading mode checks are not necessary (and do not work) on target // platforms that do not have threading (such as webassembly) // -// threading mode checks are not possible when built as a loadable extension -// since the sqlite3_threadsafe, sqlite3_config, and sqlite3_initialize -// API calls are not available via the sqlite3_api_routines struct. -#[cfg(any( - target_arch = "wasm32", - feature = "loadable_extension", - feature = "loadable_extension_embedded", -))] +// threading mode checks are also not possible when built as a loadable extension +// since the sqlite3_threadsafe, sqlite3_config, and sqlite3_initialize API calls +// are not available via the sqlite3_api_routines struct. +#[cfg(any(target_arch = "wasm32", feature = "loadable_extension",))] +#[allow(clippy::unnecessary_wraps)] fn ensure_safe_sqlite_threading_mode() -> Result<()> { Ok(()) } -#[cfg(not(any( - target_arch = "wasm32", - feature = "loadable_extension", - feature = "loadable_extension_embedded", -)))] +#[cfg(not(any(target_arch = "wasm32", feature = "loadable_extension",)))] fn ensure_safe_sqlite_threading_mode() -> Result<()> { use crate::version::version_number; use std::sync::atomic::Ordering; @@ -443,18 +432,14 @@ fn ensure_safe_sqlite_threading_mode() -> Result<()> { } unsafe { - let msg = "\ -Could not ensure safe initialization of SQLite. -To fix this, either: -* Upgrade SQLite to at least version 3.7.0 -* Ensure that SQLite has been initialized in Multi-thread or Serialized mode and call - rusqlite::bypass_sqlite_initialization() prior to your first connection attempt."; - - if ffi::sqlite3_config(ffi::SQLITE_CONFIG_MULTITHREAD) != ffi::SQLITE_OK { - panic!(msg); - } - if ffi::sqlite3_initialize() != ffi::SQLITE_OK { - panic!(msg); + if ffi::sqlite3_config(ffi::SQLITE_CONFIG_MULTITHREAD) != ffi::SQLITE_OK || ffi::sqlite3_initialize() != ffi::SQLITE_OK { + panic!( + "Could not ensure safe initialization of SQLite.\n\ + To fix this, either:\n\ + * Upgrade SQLite to at least version 3.7.0\n\ + * Ensure that SQLite has been initialized in Multi-thread or Serialized mode and call\n\ + rusqlite::bypass_sqlite_initialization() prior to your first connection attempt." + ); } } }); diff --git a/src/lib.rs b/src/lib.rs index 71230e2d7..bce8b1c63 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -71,10 +71,6 @@ use crate::types::ValueRef; pub use crate::cache::CachedStatement; pub use crate::column::Column; -#[cfg(any( - feature = "loadable_extension", - feature = "loadable_extension_embedded" -))] pub use crate::error::to_sqlite_error; pub use crate::error::Error; pub use crate::ffi::ErrorCode; @@ -101,10 +97,6 @@ mod cache; #[cfg(feature = "collation")] mod collation; mod column; -#[cfg(not(any( - feature = "loadable_extension", - feature = "loadable_extension_embedded" -)))] pub mod config; #[cfg(any(feature = "functions", feature = "vtab"))] mod context; @@ -531,7 +523,7 @@ impl Connection { /// fn insert(conn: &Connection) -> Result { /// conn.execute( /// "INSERT INTO test (name) VALUES (:name)", - /// rusqlite::named_params!{ ":name": "one" }, + /// &[(":name", "one")], /// ) /// } /// ``` @@ -682,8 +674,8 @@ impl Connection { /// # use rusqlite::{Connection, Result}; /// fn insert_new_people(conn: &Connection) -> Result<()> { /// let mut stmt = conn.prepare("INSERT INTO People (name) VALUES (?)")?; - /// stmt.execute(&["Joe Smith"])?; - /// stmt.execute(&["Bob Jones"])?; + /// stmt.execute(["Joe Smith"])?; + /// stmt.execute(["Bob Jones"])?; /// Ok(()) /// } /// ``` @@ -1018,10 +1010,8 @@ impl InterruptHandle { pub fn interrupt(&self) { let db_handle = self.db_lock.lock().unwrap(); if !db_handle.is_null() { - #[cfg(not(any( - feature = "loadable_extension", - feature = "loadable_extension_embedded" - )))] // no sqlite3_interrupt in a loadable extension + #[cfg(not(feature = "loadable_extension"))] + // no sqlite3_interrupt in a loadable extension unsafe { ffi::sqlite3_interrupt(*db_handle) } @@ -1099,7 +1089,7 @@ mod test { tx1.query_row("SELECT x FROM foo LIMIT 1", [], |_| Ok(()))?; tx2.query_row("SELECT x FROM foo LIMIT 1", [], |_| Ok(()))?; - tx1.execute("INSERT INTO foo VALUES(?1)", &[&1])?; + tx1.execute("INSERT INTO foo VALUES(?1)", [1])?; let _ = tx2.execute("INSERT INTO foo VALUES(?1)", [2]); let _ = tx1.commit(); @@ -1332,8 +1322,8 @@ mod test { assert_eq!(insert_stmt.execute([2i32])?, 1); assert_eq!(insert_stmt.execute([3i32])?, 1); - assert_eq!(insert_stmt.execute(["hello".to_string()])?, 1); - assert_eq!(insert_stmt.execute(["goodbye".to_string()])?, 1); + assert_eq!(insert_stmt.execute(["hello"])?, 1); + assert_eq!(insert_stmt.execute(["goodbye"])?, 1); assert_eq!(insert_stmt.execute([types::Null])?, 1); let mut update_stmt = db.prepare("UPDATE foo SET x=? WHERE x) -> Result<()>; + fn __bind_in(self, stmt: &mut Statement<'_>) -> Result<()>; } // Explicitly impl for empty array. Critically, for `conn.execute([])` to be @@ -172,18 +172,18 @@ pub trait Params: Sealed { impl Sealed for [&dyn ToSql; 0] {} impl Params for [&dyn ToSql; 0] { #[inline] - fn bind_in(self, stmt: &mut Statement<'_>) -> Result<()> { + fn __bind_in(self, stmt: &mut Statement<'_>) -> Result<()> { // Note: Can't just return `Ok(())` — `Statement::bind_parameters` // checks that the right number of params were passed too. // TODO: we should have tests for `Error::InvalidParameterCount`... - stmt.bind_parameters(crate::params![]) + stmt.bind_parameters(&[] as &[&dyn ToSql]) } } impl Sealed for &[&dyn ToSql] {} impl Params for &[&dyn ToSql] { #[inline] - fn bind_in(self, stmt: &mut Statement<'_>) -> Result<()> { + fn __bind_in(self, stmt: &mut Statement<'_>) -> Result<()> { stmt.bind_parameters(self) } } @@ -191,7 +191,7 @@ impl Params for &[&dyn ToSql] { impl Sealed for &[(&str, &dyn ToSql)] {} impl Params for &[(&str, &dyn ToSql)] { #[inline] - fn bind_in(self, stmt: &mut Statement<'_>) -> Result<()> { + fn __bind_in(self, stmt: &mut Statement<'_>) -> Result<()> { stmt.bind_parameters_named(self) } } @@ -202,19 +202,20 @@ macro_rules! impl_for_array_ref { // avoid the compile time hit from making them all inline for now. impl Sealed for &[&T; $N] {} impl Params for &[&T; $N] { - fn bind_in(self, stmt: &mut Statement<'_>) -> Result<()> { + fn __bind_in(self, stmt: &mut Statement<'_>) -> Result<()> { stmt.bind_parameters(self) } } impl Sealed for &[(&str, &T); $N] {} impl Params for &[(&str, &T); $N] { - fn bind_in(self, stmt: &mut Statement<'_>) -> Result<()> { + fn __bind_in(self, stmt: &mut Statement<'_>) -> Result<()> { stmt.bind_parameters_named(self) } } impl Sealed for [T; $N] {} impl Params for [T; $N] { - fn bind_in(self, stmt: &mut Statement<'_>) -> Result<()> { + #[inline] + fn __bind_in(self, stmt: &mut Statement<'_>) -> Result<()> { stmt.bind_parameters(&self) } } @@ -351,7 +352,7 @@ where I::Item: ToSql, { #[inline] - fn bind_in(self, stmt: &mut Statement<'_>) -> Result<()> { + fn __bind_in(self, stmt: &mut Statement<'_>) -> Result<()> { stmt.bind_parameters(self.0) } } diff --git a/src/pragma.rs b/src/pragma.rs index 259d9708c..16a63071b 100644 --- a/src/pragma.rs +++ b/src/pragma.rs @@ -298,15 +298,15 @@ fn is_identifier(s: &str) -> bool { } fn is_identifier_start(c: char) -> bool { - (c >= 'A' && c <= 'Z') || c == '_' || (c >= 'a' && c <= 'z') || c > '\x7F' + ('A'..='Z').contains(&c) || c == '_' || ('a'..='z').contains(&c) || c > '\x7F' } fn is_identifier_continue(c: char) -> bool { c == '$' - || (c >= '0' && c <= '9') - || (c >= 'A' && c <= 'Z') + || ('0'..='9').contains(&c) + || ('A'..='Z').contains(&c) || c == '_' - || (c >= 'a' && c <= 'z') + || ('a'..='z').contains(&c) || c > '\x7F' } @@ -379,7 +379,7 @@ mod test { let db = Connection::open_in_memory()?; let mut table_info = db.prepare("SELECT * FROM pragma_table_info(?)")?; let mut columns = Vec::new(); - let mut rows = table_info.query(&["sqlite_master"])?; + let mut rows = table_info.query(["sqlite_master"])?; while let Some(row) = rows.next()? { let row = row; diff --git a/src/raw_statement.rs b/src/raw_statement.rs index 45e1bbc74..eda47fb79 100644 --- a/src/raw_statement.rs +++ b/src/raw_statement.rs @@ -1,9 +1,5 @@ use super::ffi; use super::unlock_notify; -#[cfg(not(any( - feature = "loadable_extension", - feature = "loadable_extension_embedded" -)))] use super::StatementStatus; #[cfg(feature = "modern_sqlite")] use crate::util::SqliteMallocString; @@ -174,6 +170,7 @@ impl RawStatement { r } + // does not work for PRAGMA #[inline] #[cfg(all(feature = "extra_check", feature = "modern_sqlite"))] // 3.7.4 pub fn readonly(&self) -> bool { @@ -186,10 +183,6 @@ impl RawStatement { unsafe { SqliteMallocString::from_raw(ffi::sqlite3_expanded_sql(self.ptr)) } } - #[cfg(not(any( - feature = "loadable_extension", - feature = "loadable_extension_embedded" - )))] #[inline] pub fn get_status(&self, status: StatementStatus, reset: bool) -> i32 { assert!(!self.ptr.is_null()); diff --git a/src/session.rs b/src/session.rs index b41106afd..8ced6eaa3 100644 --- a/src/session.rs +++ b/src/session.rs @@ -791,7 +791,7 @@ mod test { assert!(session.is_empty()); session.attach(None)?; - db.execute("INSERT INTO foo (t) VALUES (?);", &["bar"])?; + db.execute("INSERT INTO foo (t) VALUES (?);", ["bar"])?; session.changeset() } @@ -804,7 +804,7 @@ mod test { assert!(session.is_empty()); session.attach(None)?; - db.execute("INSERT INTO foo (t) VALUES (?);", &["bar"])?; + db.execute("INSERT INTO foo (t) VALUES (?);", ["bar"])?; let mut output = Vec::new(); session.changeset_strm(&mut output)?; @@ -864,7 +864,7 @@ mod test { )?; assert!(!CALLED.load(Ordering::Relaxed)); - let check = db.query_row("SELECT 1 FROM foo WHERE t = ?", &["bar"], |row| { + let check = db.query_row("SELECT 1 FROM foo WHERE t = ?", ["bar"], |row| { row.get::<_, i32>(0) })?; assert_eq!(1, check); @@ -899,7 +899,7 @@ mod test { |_conflict_type, _item| ConflictAction::SQLITE_CHANGESET_OMIT, )?; - let check = db.query_row("SELECT 1 FROM foo WHERE t = ?", &["bar"], |row| { + let check = db.query_row("SELECT 1 FROM foo WHERE t = ?", ["bar"], |row| { row.get::<_, i32>(0) })?; assert_eq!(1, check); @@ -915,7 +915,7 @@ mod test { assert!(session.is_empty()); session.attach(None)?; - db.execute("INSERT INTO foo (t) VALUES (?);", &["bar"])?; + db.execute("INSERT INTO foo (t) VALUES (?);", ["bar"])?; assert!(!session.is_empty()); Ok(()) diff --git a/src/statement.rs b/src/statement.rs index 7f0c9b3b3..e7171e768 100644 --- a/src/statement.rs +++ b/src/statement.rs @@ -82,7 +82,7 @@ impl Statement<'_> { /// underlying SQLite call fails. #[inline] pub fn execute(&mut self, params: P) -> Result { - params.bind_in(self)?; + params.__bind_in(self)?; self.execute_with_bound_parameters() } @@ -178,7 +178,7 @@ impl Statement<'_> { /// # use rusqlite::{Connection, Result}; /// fn query(conn: &Connection, name: &str) -> Result<()> { /// let mut stmt = conn.prepare("SELECT * FROM test where name = ?")?; - /// let mut rows = stmt.query(&[name])?; + /// let mut rows = stmt.query([name])?; /// while let Some(row) = rows.next()? { /// // ... /// } @@ -192,7 +192,7 @@ impl Statement<'_> { /// # use rusqlite::{Connection, Result}; /// fn query(conn: &Connection) -> Result<()> { /// let mut stmt = conn.prepare("SELECT * FROM test where name = :name")?; - /// let mut rows = stmt.query(&[(":name", &"one")])?; + /// let mut rows = stmt.query(&[(":name", "one")])?; /// while let Some(row) = rows.next()? { /// // ... /// } @@ -220,8 +220,7 @@ impl Statement<'_> { /// Will return `Err` if binding parameters fails. #[inline] pub fn query(&mut self, params: P) -> Result> { - self.check_readonly()?; - params.bind_in(self)?; + params.__bind_in(self)?; Ok(Rows::new(self)) } @@ -352,7 +351,7 @@ impl Statement<'_> { /// fn get_names(conn: &Connection) -> Result> { /// let mut stmt = conn.prepare("SELECT name FROM people WHERE id = :id")?; /// let rows = - /// stmt.query_and_then(&[(":id", &"one")], |row| name_to_person(row.get(0)?))?; + /// stmt.query_and_then(&[(":id", "one")], |row| name_to_person(row.get(0)?))?; /// /// let mut persons = Vec::new(); /// for person_result in rows { @@ -369,7 +368,7 @@ impl Statement<'_> { /// # use rusqlite::{Connection, Result}; /// fn get_names(conn: &Connection) -> Result> { /// let mut stmt = conn.prepare("SELECT name FROM people WHERE id = ?")?; - /// let rows = stmt.query_and_then(&["one"], |row| row.get::<_, String>(0))?; + /// let rows = stmt.query_and_then(["one"], |row| row.get::<_, String>(0))?; /// /// let mut persons = Vec::new(); /// for person_result in rows { @@ -718,21 +717,6 @@ impl Statement<'_> { self.conn.decode_result(stmt.finalize()) } - #[cfg(not(feature = "modern_sqlite"))] - #[inline] - fn check_readonly(&self) -> Result<()> { - Ok(()) - } - - #[cfg(feature = "modern_sqlite")] - #[inline] - fn check_readonly(&self) -> Result<()> { - /*if !self.stmt.readonly() { does not work for PRAGMA - return Err(Error::InvalidQuery); - }*/ - Ok(()) - } - #[cfg(all(feature = "modern_sqlite", feature = "extra_check"))] #[inline] fn check_update(&self) -> Result<()> { @@ -755,6 +739,7 @@ impl Statement<'_> { #[cfg(not(feature = "extra_check"))] #[inline] + #[allow(clippy::unnecessary_wraps)] fn check_update(&self) -> Result<()> { Ok(()) } @@ -770,10 +755,6 @@ impl Statement<'_> { /// Get the value for one of the status counters for this statement. #[inline] - #[cfg(not(any( - feature = "loadable_extension", - feature = "loadable_extension_embedded" - )))] pub fn get_status(&self, status: StatementStatus) -> i32 { self.stmt.get_status(status, false) } @@ -781,10 +762,6 @@ impl Statement<'_> { /// Reset the value of one of the status counters for this statement, #[inline] /// returning the value it had before resetting. - #[cfg(not(any( - feature = "loadable_extension", - feature = "loadable_extension_embedded" - )))] pub fn reset_status(&self, status: StatementStatus) -> i32 { self.stmt.get_status(status, true) } @@ -801,6 +778,7 @@ impl Statement<'_> { #[cfg(not(feature = "extra_check"))] #[inline] + #[allow(clippy::unnecessary_wraps)] pub(crate) fn check_no_tail(&self) -> Result<()> { Ok(()) } @@ -1007,7 +985,7 @@ mod test { ); assert_eq!( 1i32, - stmt.query_row::(&[(":name", &"one")], |r| r.get(0))? + stmt.query_row::(&[(":name", "one")], |r| r.get(0))? ); Ok(()) } @@ -1032,7 +1010,7 @@ mod test { // plain api { - let mut rows = stmt.query(&[(":name", &"one")])?; + let mut rows = stmt.query(&[(":name", "one")])?; let id: Result = rows.next()?.unwrap().get(0); assert_eq!(Ok(1), id); } @@ -1062,7 +1040,7 @@ mod test { } // plain api { - let mut rows = stmt.query_map(&[(":name", &"one")], |row| { + let mut rows = stmt.query_map(&[(":name", "one")], |row| { let id: Result = row.get(0); id.map(|i| 2 * i) })?; @@ -1119,7 +1097,7 @@ mod test { db.execute_batch(sql)?; let mut stmt = db.prepare("SELECT id FROM test where name = :name ORDER BY id ASC")?; - let mut rows = stmt.query_and_then(&[(":name", &"one")], |row| { + let mut rows = stmt.query_and_then(&[(":name", "one")], |row| { let id: i32 = row.get(0)?; if id == 1 { Ok(id) @@ -1196,8 +1174,8 @@ mod test { db.execute_batch(sql)?; let mut stmt = db.prepare("INSERT INTO test (x, y) VALUES (:x, :y)")?; - stmt.execute(&[(":x", &"one")])?; - stmt.execute(&[(":y", &"two")])?; + stmt.execute(&[(":x", "one")])?; + stmt.execute(&[(":y", "two")])?; let result: String = db.query_row("SELECT x FROM test WHERE y = 'two'", [], |row| row.get(0))?; @@ -1210,9 +1188,9 @@ mod test { let db = Connection::open_in_memory()?; db.execute_batch("CREATE TABLE foo(x INTEGER UNIQUE)")?; let mut stmt = db.prepare("INSERT OR IGNORE INTO foo (x) VALUES (?)")?; - assert_eq!(stmt.insert(&[&1i32])?, 1); - assert_eq!(stmt.insert(&[&2i32])?, 2); - match stmt.insert(&[&1i32]).unwrap_err() { + assert_eq!(stmt.insert([1i32])?, 1); + assert_eq!(stmt.insert([2i32])?, 2); + match stmt.insert([1i32]).unwrap_err() { Error::StatementChangedRows(0) => (), err => panic!("Unexpected error {}", err), } @@ -1251,8 +1229,8 @@ mod test { db.execute_batch(sql)?; let mut stmt = db.prepare("SELECT 1 FROM foo WHERE x = ?")?; assert!(stmt.exists([1i32])?); - assert!(stmt.exists(&[&2i32])?); - assert!(!stmt.exists([&0i32])?); + assert!(stmt.exists([2i32])?); + assert!(!stmt.exists([0i32])?); Ok(()) } diff --git a/src/trace.rs b/src/trace.rs index 26de9f4a1..d59e9019b 100644 --- a/src/trace.rs +++ b/src/trace.rs @@ -2,6 +2,8 @@ use std::ffi::CStr; use std::mem; +#[cfg(not(feature = "loadable_extension"))] +use std::os::raw::c_int; use std::os::raw::{c_char, c_void}; use std::panic::catch_unwind; use std::ptr; @@ -24,13 +26,9 @@ use crate::Connection; /// * It must be threadsafe if SQLite is used in a multithreaded way. /// /// cf [The Error And Warning Log](http://sqlite.org/errlog.html). -#[cfg(not(any( - feature = "loadable_extension", - feature = "loadable_extension_embedded" -)))] -pub unsafe fn config_log(callback: Option) -> crate::Result<()> { +#[cfg(not(feature = "loadable_extension"))] +pub unsafe fn config_log(callback: Option) -> crate::Result<()> { use crate::error::error_from_sqlite_code; - use std::os::raw::c_int; extern "C" fn log_callback(p_arg: *mut c_void, err: c_int, msg: *const c_char) { let c_slice = unsafe { CStr::from_ptr(msg).to_bytes() }; let callback: fn(c_int, &str) = unsafe { mem::transmute(p_arg) }; @@ -60,14 +58,11 @@ pub unsafe fn config_log(callback: Option) -> cra /// `feature = "trace"` Write a message into the error log established by /// `config_log`. -#[cfg(not(any( - feature = "loadable_extension", - feature = "loadable_extension_embedded" -)))] #[inline] -pub fn log(err_code: std::os::raw::c_int, msg: &str) { - use std::ffi::CString; - let msg = CString::new(msg).expect("SQLite log messages cannot contain embedded zeroes"); +#[cfg(not(feature = "loadable_extension"))] +pub fn log(err_code: c_int, msg: &str) { + let msg = + std::ffi::CString::new(msg).expect("SQLite log messages cannot contain embedded zeroes"); unsafe { ffi::sqlite3_log(err_code, b"%s\0" as *const _ as *const c_char, msg.as_ptr()); } @@ -153,8 +148,8 @@ mod test { let mut db = Connection::open_in_memory()?; db.trace(Some(tracer)); { - let _ = db.query_row("SELECT ?", &[&1i32], |_| Ok(())); - let _ = db.query_row("SELECT ?", &["hello"], |_| Ok(())); + let _ = db.query_row("SELECT ?", [1i32], |_| Ok(())); + let _ = db.query_row("SELECT ?", ["hello"], |_| Ok(())); } db.trace(None); { diff --git a/src/types/chrono.rs b/src/types/chrono.rs index 728878624..fde8546d3 100644 --- a/src/types/chrono.rs +++ b/src/types/chrono.rs @@ -1,7 +1,5 @@ //! Convert most of the [Time Strings](http://sqlite.org/lang_datefunc.html) to chrono types. -use std::borrow::Cow; - use chrono::{DateTime, Local, NaiveDate, NaiveDateTime, NaiveTime, TimeZone, Utc}; use crate::types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput, ValueRef}; @@ -11,7 +9,7 @@ use crate::Result; impl ToSql for NaiveDate { #[inline] fn to_sql(&self) -> Result> { - let date_str = self.format("%Y-%m-%d").to_string(); + let date_str = self.format("%F").to_string(); Ok(ToSqlOutput::from(date_str)) } } @@ -22,7 +20,7 @@ impl FromSql for NaiveDate { fn column_result(value: ValueRef<'_>) -> FromSqlResult { value .as_str() - .and_then(|s| match NaiveDate::parse_from_str(s, "%Y-%m-%d") { + .and_then(|s| match NaiveDate::parse_from_str(s, "%F") { Ok(dt) => Ok(dt), Err(err) => Err(FromSqlError::Other(Box::new(err))), }) @@ -33,7 +31,7 @@ impl FromSql for NaiveDate { impl ToSql for NaiveTime { #[inline] fn to_sql(&self) -> Result> { - let date_str = self.format("%H:%M:%S%.f").to_string(); + let date_str = self.format("%T%.f").to_string(); Ok(ToSqlOutput::from(date_str)) } } @@ -44,8 +42,8 @@ impl FromSql for NaiveTime { value.as_str().and_then(|s| { let fmt = match s.len() { 5 => "%H:%M", - 8 => "%H:%M:%S", - _ => "%H:%M:%S%.f", + 8 => "%T", + _ => "%T%.f", }; match NaiveTime::parse_from_str(s, fmt) { Ok(dt) => Ok(dt), @@ -56,11 +54,11 @@ impl FromSql for NaiveTime { } /// ISO 8601 combined date and time without timezone => -/// "YYYY-MM-DDTHH:MM:SS.SSS" +/// "YYYY-MM-DD HH:MM:SS.SSS" impl ToSql for NaiveDateTime { #[inline] fn to_sql(&self) -> Result> { - let date_str = self.format("%Y-%m-%dT%H:%M:%S%.f").to_string(); + let date_str = self.format("%F %T%.f").to_string(); Ok(ToSqlOutput::from(date_str)) } } @@ -72,9 +70,9 @@ impl FromSql for NaiveDateTime { fn column_result(value: ValueRef<'_>) -> FromSqlResult { value.as_str().and_then(|s| { let fmt = if s.len() >= 11 && s.as_bytes()[10] == b'T' { - "%Y-%m-%dT%H:%M:%S%.f" + "%FT%T%.f" } else { - "%Y-%m-%d %H:%M:%S%.f" + "%F %T%.f" }; match NaiveDateTime::parse_from_str(s, fmt) { @@ -86,34 +84,29 @@ impl FromSql for NaiveDateTime { } /// Date and time with time zone => UTC RFC3339 timestamp -/// ("YYYY-MM-DDTHH:MM:SS.SSS+00:00"). +/// ("YYYY-MM-DD HH:MM:SS.SSS+00:00"). impl ToSql for DateTime { #[inline] fn to_sql(&self) -> Result> { - Ok(ToSqlOutput::from(self.with_timezone(&Utc).to_rfc3339())) + let date_str = self.with_timezone(&Utc).format("%F %T%.f%:z").to_string(); + Ok(ToSqlOutput::from(date_str)) } } -/// RFC3339 ("YYYY-MM-DDTHH:MM:SS.SSS[+-]HH:MM") into `DateTime`. +/// RFC3339 ("YYYY-MM-DD HH:MM:SS.SSS[+-]HH:MM") into `DateTime`. impl FromSql for DateTime { fn column_result(value: ValueRef<'_>) -> FromSqlResult { { // Try to parse value as rfc3339 first. let s = value.as_str()?; - // If timestamp looks space-separated, make a copy and replace it with 'T'. - let s = if s.len() >= 11 && s.as_bytes()[10] == b' ' { - let mut s = s.to_string(); - unsafe { - let sbytes = s.as_mut_vec(); - sbytes[10] = b'T'; - } - Cow::Owned(s) + let fmt = if s.len() >= 11 && s.as_bytes()[10] == b'T' { + "%FT%T%.f%:z" } else { - Cow::Borrowed(s) + "%F %T%.f%:z" }; - if let Ok(dt) = DateTime::parse_from_rfc3339(&s) { + if let Ok(dt) = DateTime::parse_from_str(s, fmt) { return Ok(dt.with_timezone(&Utc)); } } @@ -123,7 +116,7 @@ impl FromSql for DateTime { } } -/// RFC3339 ("YYYY-MM-DDTHH:MM:SS.SSS[+-]HH:MM") into `DateTime`. +/// RFC3339 ("YYYY-MM-DD HH:MM:SS.SSS[+-]HH:MM") into `DateTime`. impl FromSql for DateTime { #[inline] fn column_result(value: ValueRef<'_>) -> FromSqlResult { @@ -147,7 +140,7 @@ mod test { fn test_naive_date() -> Result<()> { let db = checked_memory_handle()?; let date = NaiveDate::from_ymd(2016, 2, 23); - db.execute("INSERT INTO foo (t) VALUES (?)", &[&date])?; + db.execute("INSERT INTO foo (t) VALUES (?)", [date])?; let s: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?; assert_eq!("2016-02-23", s); @@ -160,7 +153,7 @@ mod test { fn test_naive_time() -> Result<()> { let db = checked_memory_handle()?; let time = NaiveTime::from_hms(23, 56, 4); - db.execute("INSERT INTO foo (t) VALUES (?)", &[&time])?; + db.execute("INSERT INTO foo (t) VALUES (?)", [time])?; let s: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?; assert_eq!("23:56:04", s); @@ -176,10 +169,10 @@ mod test { let time = NaiveTime::from_hms(23, 56, 4); let dt = NaiveDateTime::new(date, time); - db.execute("INSERT INTO foo (t) VALUES (?)", &[&dt])?; + db.execute("INSERT INTO foo (t) VALUES (?)", [dt])?; let s: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?; - assert_eq!("2016-02-23T23:56:04", s); + assert_eq!("2016-02-23 23:56:04", s); let v: NaiveDateTime = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?; assert_eq!(dt, v); @@ -197,10 +190,10 @@ mod test { let dt = NaiveDateTime::new(date, time); let utc = Utc.from_utc_datetime(&dt); - db.execute("INSERT INTO foo (t) VALUES (?)", &[&utc])?; + db.execute("INSERT INTO foo (t) VALUES (?)", [utc])?; let s: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?; - assert_eq!("2016-02-23T23:56:04.789+00:00", s); + assert_eq!("2016-02-23 23:56:04.789+00:00", s); let v1: DateTime = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?; assert_eq!(utc, v1); @@ -226,7 +219,7 @@ mod test { let dt = NaiveDateTime::new(date, time); let local = Local.from_local_datetime(&dt).single().unwrap(); - db.execute("INSERT INTO foo (t) VALUES (?)", &[&local])?; + db.execute("INSERT INTO foo (t) VALUES (?)", [local])?; // Stored string should be in UTC let s: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?; @@ -252,4 +245,20 @@ mod test { assert!(result.is_ok()); Ok(()) } + + #[test] + fn test_naive_date_time_param() -> Result<()> { + let db = checked_memory_handle()?; + let result: Result = db.query_row("SELECT 1 WHERE ? BETWEEN datetime('now', '-1 minute') AND datetime('now', '+1 minute')", [Utc::now().naive_utc()], |r| r.get(0)); + assert!(result.is_ok()); + Ok(()) + } + + #[test] + fn test_date_time_param() -> Result<()> { + let db = checked_memory_handle()?; + let result: Result = db.query_row("SELECT 1 WHERE ? BETWEEN datetime('now', '-1 minute') AND datetime('now', '+1 minute')", [Utc::now()], |r| r.get(0)); + assert!(result.is_ok()); + Ok(()) + } } diff --git a/src/types/time.rs b/src/types/time.rs index 14c92e15d..ac182a9bb 100644 --- a/src/types/time.rs +++ b/src/types/time.rs @@ -4,7 +4,7 @@ use crate::Result; use time::{OffsetDateTime, PrimitiveDateTime, UtcOffset}; const CURRENT_TIMESTAMP_FMT: &str = "%Y-%m-%d %H:%M:%S"; -const SQLITE_DATETIME_FMT: &str = "%Y-%m-%dT%H:%M:%S.%NZ"; +const SQLITE_DATETIME_FMT: &str = "%Y-%m-%d %H:%M:%S.%NZ"; const SQLITE_DATETIME_FMT_LEGACY: &str = "%Y-%m-%d %H:%M:%S:%N %z"; impl ToSql for OffsetDateTime { @@ -60,7 +60,7 @@ mod test { ts_vec.push(make_datetime(10_000_000_000, 0)); //November 20, 2286 for ts in ts_vec { - db.execute("INSERT INTO foo(t) VALUES (?)", &[&ts])?; + db.execute("INSERT INTO foo(t) VALUES (?)", [ts])?; let from: OffsetDateTime = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?; @@ -79,4 +79,12 @@ mod test { assert!(result.is_ok()); Ok(()) } + + #[test] + fn test_param() -> Result<()> { + let db = checked_memory_handle()?; + let result: Result = db.query_row("SELECT 1 WHERE ? BETWEEN datetime('now', '-1 minute') AND datetime('now', '+1 minute')", [OffsetDateTime::now_utc()], |r| r.get(0)); + assert!(result.is_ok()); + Ok(()) + } } diff --git a/src/types/url.rs b/src/types/url.rs index 8991385cf..fea850007 100644 --- a/src/types/url.rs +++ b/src/types/url.rs @@ -37,7 +37,7 @@ mod test { } fn get_url(db: &Connection, id: i64) -> Result { - db.query_row("SELECT v FROM urls WHERE i = ?", params![id], |r| r.get(0)) + db.query_row("SELECT v FROM urls WHERE i = ?", [id], |r| r.get(0)) } #[test] diff --git a/src/util/mod.rs b/src/util/mod.rs index 3ccf86796..b57f87cd4 100644 --- a/src/util/mod.rs +++ b/src/util/mod.rs @@ -4,18 +4,5 @@ mod small_cstr; pub(crate) use param_cache::ParamIndexCache; pub(crate) use small_cstr::SmallCString; -// Doesn't use any modern features or vtab stuff, but is only used by them. -#[cfg(any( - feature = "loadable_extension", - feature = "loadable_extension_embedded", - feature = "modern_sqlite", - feature = "vtab" -))] mod sqlite_string; -#[cfg(any( - feature = "loadable_extension", - feature = "loadable_extension_embedded", - feature = "modern_sqlite", - feature = "vtab" -))] -pub(crate) use sqlite_string::{alloc, SqliteMallocString}; +pub(crate) use sqlite_string::SqliteMallocString; diff --git a/src/util/sqlite_string.rs b/src/util/sqlite_string.rs index e416be16a..a57ca2bc1 100644 --- a/src/util/sqlite_string.rs +++ b/src/util/sqlite_string.rs @@ -1,26 +1,8 @@ -// This is used when either vtab or modern-sqlite is on. Different methods are -// used in each feature. Avoid having to track this for each function. We will -// still warn for anything that's not used by either, though. -#![cfg_attr( - not(all( - feature = "vtab", - feature = "loadable_extension", - feature = "loadable_extension_embedded", - feature = "modern-sqlite" - )), - allow(dead_code) -)] use crate::ffi; use std::marker::PhantomData; use std::os::raw::{c_char, c_int}; use std::ptr::NonNull; -// Space to hold this string must be obtained -// from an SQLite memory allocation function -pub(crate) fn alloc(s: &str) -> *mut c_char { - SqliteMallocString::from_str(s).into_raw() -} - /// A string we own that's allocated on the SQLite heap. Automatically calls /// `sqlite3_free` when dropped, unless `into_raw` (or `into_inner`) is called /// on it. If constructed from a rust string, `sqlite3_malloc` is used. @@ -51,7 +33,7 @@ impl SqliteMallocString { /// SAFETY: Caller must be certain that `m` a nul-terminated c string /// allocated by sqlite3_malloc, and that SQLite expects us to free it! #[inline] - unsafe fn from_raw_nonnull(ptr: NonNull) -> Self { + pub(crate) unsafe fn from_raw_nonnull(ptr: NonNull) -> Self { Self { ptr, _boo: PhantomData, @@ -68,7 +50,7 @@ impl SqliteMallocString { /// Get the pointer behind `self`. After this is called, we no longer manage /// it. #[inline] - fn into_inner(self) -> NonNull { + pub(crate) fn into_inner(self) -> NonNull { let p = self.ptr; std::mem::forget(self); p @@ -77,19 +59,19 @@ impl SqliteMallocString { /// Get the pointer behind `self`. After this is called, we no longer manage /// it. #[inline] - fn into_raw(self) -> *mut c_char { + pub(crate) fn into_raw(self) -> *mut c_char { self.into_inner().as_ptr() } /// Borrow the pointer behind `self`. We still manage it when this function /// returns. If you want to relinquish ownership, use `into_raw`. #[inline] - fn as_ptr(&self) -> *const c_char { + pub(crate) fn as_ptr(&self) -> *const c_char { self.ptr.as_ptr() } #[inline] - fn as_cstr(&self) -> &std::ffi::CStr { + pub(crate) fn as_cstr(&self) -> &std::ffi::CStr { unsafe { std::ffi::CStr::from_ptr(self.as_ptr()) } } @@ -113,7 +95,7 @@ impl SqliteMallocString { /// /// This means it's safe to use in extern "C" functions even outside of /// catch_unwind. - fn from_str(s: &str) -> Self { + pub(crate) fn from_str(s: &str) -> Self { use std::convert::TryFrom; let s = if s.as_bytes().contains(&0) { std::borrow::Cow::Owned(make_nonnull(s)) diff --git a/src/vtab/array.rs b/src/vtab/array.rs index 53b31a770..713604c54 100644 --- a/src/vtab/array.rs +++ b/src/vtab/array.rs @@ -18,7 +18,7 @@ //! // Note: A `Rc>` must be used as the parameter. //! let values = Rc::new(v.iter().copied().map(Value::from).collect::>()); //! let mut stmt = db.prepare("SELECT value from rarray(?);")?; -//! let rows = stmt.query_map(params![values], |row| row.get::<_, i64>(0))?; +//! let rows = stmt.query_map([values], |row| row.get::<_, i64>(0))?; //! for value in rows { //! println!("{}", value?); //! } @@ -157,7 +157,7 @@ impl ArrayTabCursor<'_> { unsafe impl VTabCursor for ArrayTabCursor<'_> { fn filter(&mut self, idx_num: c_int, _idx_str: Option<&str>, args: &Values<'_>) -> Result<()> { if idx_num > 0 { - self.ptr = args.get_array(0)?; + self.ptr = args.get_array(0); } else { self.ptr = None; } diff --git a/src/vtab/mod.rs b/src/vtab/mod.rs index a6093670d..4d9ad6540 100644 --- a/src/vtab/mod.rs +++ b/src/vtab/mod.rs @@ -17,11 +17,10 @@ use std::ptr; use std::slice; use crate::context::set_result; -use crate::error::{error_from_sqlite_code, to_sqlite_error}; +use crate::error::error_from_sqlite_code; use crate::ffi; pub use crate::ffi::{sqlite3_vtab, sqlite3_vtab_cursor}; use crate::types::{FromSql, FromSqlError, ToSql, ValueRef}; -use crate::util::alloc; use crate::{str_to_cstring, Connection, Error, InnerConnection, Result}; // let conn: Connection = ...; @@ -572,19 +571,19 @@ impl Values<'_> { // `sqlite3_value_type` returns `SQLITE_NULL` for pointer. // So it seems not possible to enhance `ValueRef::from_value`. #[cfg(feature = "array")] - fn get_array(&self, idx: usize) -> Result> { + fn get_array(&self, idx: usize) -> Option { use crate::types::Value; let arg = self.args[idx]; let ptr = unsafe { ffi::sqlite3_value_pointer(arg, array::ARRAY_TYPE) }; if ptr.is_null() { - Ok(None) + None } else { - Ok(Some(unsafe { + Some(unsafe { let rc = array::Array::from_raw(ptr as *const Vec); let array = rc.clone(); array::Array::into_raw(rc); // don't consume it array - })) + }) } } @@ -760,7 +759,8 @@ where ffi::SQLITE_OK } else { let err = error_from_sqlite_code(rc, None); - to_sqlite_error(&err, err_msg) + *err_msg = alloc(&err.to_string()); + rc } } Err(err) => { @@ -768,7 +768,16 @@ where ffi::SQLITE_ERROR } }, - Err(err) => to_sqlite_error(&err, err_msg), + Err(Error::SqliteFailure(err, s)) => { + if let Some(s) = s { + *err_msg = alloc(&s); + } + err.extended_code + } + Err(err) => { + *err_msg = alloc(&err.to_string()); + ffi::SQLITE_ERROR + } } } @@ -802,7 +811,8 @@ where ffi::SQLITE_OK } else { let err = error_from_sqlite_code(rc, None); - to_sqlite_error(&err, err_msg) + *err_msg = alloc(&err.to_string()); + rc } } Err(err) => { @@ -810,7 +820,16 @@ where ffi::SQLITE_ERROR } }, - Err(err) => to_sqlite_error(&err, err_msg), + Err(Error::SqliteFailure(err, s)) => { + if let Some(s) = s { + *err_msg = alloc(&s); + } + err.extended_code + } + Err(err) => { + *err_msg = alloc(&err.to_string()); + ffi::SQLITE_ERROR + } } } @@ -1044,6 +1063,12 @@ unsafe fn result_error(ctx: *mut ffi::sqlite3_context, result: Result) -> } } +// Space to hold this string must be obtained +// from an SQLite memory allocation function +fn alloc(s: &str) -> *mut c_char { + crate::util::SqliteMallocString::from_str(s).into_raw() +} + #[cfg(feature = "array")] pub mod array; #[cfg(feature = "csvtab")] diff --git a/tests/config_log.rs b/tests/config_log.rs index db487c1a8..0875ba3f0 100644 --- a/tests/config_log.rs +++ b/tests/config_log.rs @@ -2,13 +2,7 @@ //! function affects SQLite process-wide and so is not safe to run as a normal //! #[test] in the library. -#[cfg(all( - feature = "trace", - not(any( - feature = "loadable_extension", - feature = "loadable_extension_embedded" - )) -))] +#[cfg(all(feature = "trace", not(feature = "loadable_extension")))] fn main() { use lazy_static::lazy_static; use std::os::raw::c_int; @@ -36,9 +30,5 @@ fn main() { assert_eq!(logs_received[0].1, "First message from rusqlite"); } -#[cfg(any( - not(feature = "trace"), - feature = "loadable_extension", - feature = "loadable_extension_embedded" -))] +#[cfg(any(not(feature = "trace"), feature = "loadable_extension",))] fn main() {} diff --git a/tests/deny_single_threaded_sqlite_config.rs b/tests/deny_single_threaded_sqlite_config.rs index cabcff7fc..1bf819af5 100644 --- a/tests/deny_single_threaded_sqlite_config.rs +++ b/tests/deny_single_threaded_sqlite_config.rs @@ -1,10 +1,7 @@ //! Ensure we reject connections when SQLite is in single-threaded mode, as it //! would violate safety if multiple Rust threads tried to use connections. -#[cfg(not(any( - feature = "loadable_extension", - feature = "loadable_extension_embedded" -)))] +#[cfg(not(feature = "loadable_extension"))] #[test] #[should_panic] fn test_error_when_singlethread_mode() { diff --git a/tests/vtab.rs b/tests/vtab.rs index 1446c2840..5c5bdefa1 100644 --- a/tests/vtab.rs +++ b/tests/vtab.rs @@ -3,7 +3,6 @@ #[cfg(feature = "vtab")] #[test] fn test_dummy_module() -> rusqlite::Result<()> { - use rusqlite::types::ToSql; use rusqlite::vtab::{ eponymous_only_module, sqlite3_vtab, sqlite3_vtab_cursor, Context, IndexInfo, VTab, VTabConnection, VTabCursor, Values, @@ -95,7 +94,7 @@ fn test_dummy_module() -> rusqlite::Result<()> { let mut s = db.prepare("SELECT * FROM dummy()")?; - let dummy = s.query_row(&[] as &[&dyn ToSql], |row| row.get::<_, i32>(0))?; + let dummy = s.query_row([], |row| row.get::<_, i32>(0))?; assert_eq!(1, dummy); Ok(()) } From e63b17f35dc2ddca9b98fd19810702bcef2ab2f8 Mon Sep 17 00:00:00 2001 From: "Joshua C. Randall" Date: Sun, 7 Mar 2021 19:39:38 +0000 Subject: [PATCH 49/61] improve loadable_extension integration test and add loadable_extension_embedded integration test --- .github/workflows/main.yml | 11 +- dummy-embedded-extension/.gitignore | 3 + dummy-embedded-extension/Cargo.toml | 26 ++++ dummy-embedded-extension/build.rs | 15 +++ .../dummy_c_host_extension.c | 22 +++ dummy-embedded-extension/integration-test.sh | 50 +++++++ dummy-embedded-extension/src/lib.rs | 127 ++++++++++++++++++ dummy-extension/Cargo.toml | 2 +- dummy-extension/integration-test.sh | 34 ++++- dummy-extension/src/lib.rs | 2 +- 10 files changed, 282 insertions(+), 10 deletions(-) create mode 100644 dummy-embedded-extension/.gitignore create mode 100644 dummy-embedded-extension/Cargo.toml create mode 100644 dummy-embedded-extension/build.rs create mode 100644 dummy-embedded-extension/dummy-c-host-extension/dummy_c_host_extension.c create mode 100755 dummy-embedded-extension/integration-test.sh create mode 100644 dummy-embedded-extension/src/lib.rs diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index cf7eb618c..97a3c3b28 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -78,14 +78,21 @@ jobs: - run: cargo test --features sqlcipher --workspace --all-targets --verbose dummy-extension: - name: Test loadable extensions with dummy-extension + name: Test loadable_extension with dummy-extension runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - uses: hecrj/setup-rust-action@v1 - - run: (cd dummy-extension && cargo build --all-targets --verbose) - run: ./dummy-extension/integration-test.sh + dummy-embedded-extension: + name: Test loadable_extension_embedded with dummy-embedded-extension + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: hecrj/setup-rust-action@v1 + - run: ./dummy-embedded-extension/integration-test.sh + sanitizer: name: Address Sanitizer runs-on: ubuntu-latest diff --git a/dummy-embedded-extension/.gitignore b/dummy-embedded-extension/.gitignore new file mode 100644 index 000000000..2074695f1 --- /dev/null +++ b/dummy-embedded-extension/.gitignore @@ -0,0 +1,3 @@ +dummy-embedded-extension.h +dummy-c-host-extension/libdummy_c_host_extension.so +target/ diff --git a/dummy-embedded-extension/Cargo.toml b/dummy-embedded-extension/Cargo.toml new file mode 100644 index 000000000..942d5ff5b --- /dev/null +++ b/dummy-embedded-extension/Cargo.toml @@ -0,0 +1,26 @@ +[package] +name = "dummy-embedded-extension" +version = "0.0.1" +authors = ["The rusqlite developers"] +edition = "2018" +repository = "https://github.com/rusqlite/rusqlite" +description = "Dummy embedded extension to demonstrate and test rusqlite feature loadable_extension_embedded" +license = "MIT" +keywords = ["sqlite", "extension"] + +[lib] +crate-type = ["cdylib"] + +[dependencies] + +[dependencies.rusqlite] +path = ".." +default-features = false +features = ["loadable_extension_embedded", "vtab", "functions", "bundled"] +version = "0.24.2" + +[build-dependencies] +cbindgen = "0.18.0" + +[workspace] +members = [] diff --git a/dummy-embedded-extension/build.rs b/dummy-embedded-extension/build.rs new file mode 100644 index 000000000..4cf0795fa --- /dev/null +++ b/dummy-embedded-extension/build.rs @@ -0,0 +1,15 @@ +extern crate cbindgen; + +use std::env; + +fn main() { + let crate_dir = env::var("CARGO_MANIFEST_DIR").unwrap(); + + // generate bindings to be included by the host extension that embeds us + cbindgen::Builder::new() + .with_language(cbindgen::Language::C) + .with_crate(crate_dir) + .generate() + .expect("Unable to generate bindings") + .write_to_file("dummy-embedded-extension.h"); +} diff --git a/dummy-embedded-extension/dummy-c-host-extension/dummy_c_host_extension.c b/dummy-embedded-extension/dummy-c-host-extension/dummy_c_host_extension.c new file mode 100644 index 000000000..71f37d234 --- /dev/null +++ b/dummy-embedded-extension/dummy-c-host-extension/dummy_c_host_extension.c @@ -0,0 +1,22 @@ +// include the sqlite3 extension header and call macros as documented in https://sqlite.org/loadext.html +#include "sqlite3ext.h" +SQLITE_EXTENSION_INIT1 + +// include the cbindgen-generated bindings for the embedded extension +#include "dummy-embedded-extension.h" + +// the extension entry point +int sqlite3_dummychostextension_init( + sqlite3 *db, + char **pzErrMsg, + const sqlite3_api_routines *pApi + ) { + int rc = SQLITE_OK; + SQLITE_EXTENSION_INIT2(pApi); + + // for this example, we essentially just pass through to the embedded + // extension and return the result. + rc = dummy_embedded_extension_init(db, pzErrMsg); + + return rc; +} diff --git a/dummy-embedded-extension/integration-test.sh b/dummy-embedded-extension/integration-test.sh new file mode 100755 index 000000000..6a876d08d --- /dev/null +++ b/dummy-embedded-extension/integration-test.sh @@ -0,0 +1,50 @@ +#!/bin/bash + +set -euf -o pipefail + +# the crate dir is where this script is located +crate_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" + +# location of the cdylib embedded library within the target dir to be embedded within the c host extension +dummy_embedded_extension_lib_dir="${crate_dir}/target/debug" +dummy_embedded_extension_lib="dummy_embedded_extension" + +# location of the c host extension to be loaded by sqlite +dummy_c_host_extension_dir="${crate_dir}/dummy-c-host-extension" +dummy_c_host_extension="${dummy_c_host_extension_dir}/libdummy_c_host_extension" # sqlite will try adding .so, .dll, .dylib to this on its own + +# expected output from vtable query +expected_vtable_output="dummy_embedded_test_value" + +# expected output from function query +expected_function_output="Dummy embedded extension loaded correctly!" + +# sqlite3 include dir (location of sqlite3ext.h) - can be set by SQLITE3_INCLUDE_DIR env var or defaults to bundled version +sqlite3_include_dir=${SQLITE3_INCLUDE_DIR:-${crate_dir}/../sqlite3} + +>&2 echo "checking for sqlite3 shell" +sqlite3_cmd=$(which sqlite3) +>&2 echo "sqlite3 found: ${sqlite3_cmd}" + +# build the dummy-embedded-extension crate +>&2 echo "building the dummy-embedded-extension crate in ${crate_dir}" +(cd "${crate_dir}" && cargo build --all-targets --verbose) +>&2 echo "successfully built the dummy-embedded-extension crate" + +# build the C-based host extension +>&2 echo "building the dummy-c-host-extension" +clang -g -fPIC -O2 -shared -I${sqlite3_include_dir} -I${crate_dir} -L${dummy_embedded_extension_lib_dir} -Wl,-rpath,${dummy_embedded_extension_lib_dir} -l${dummy_embedded_extension_lib} ${dummy_c_host_extension_dir}/dummy_c_host_extension.c -o ${dummy_c_host_extension}.so +>&2 echo "successfully built the dummy-c-host-extension" + +>&2 echo "running sqlite3 (${sqlite3_cmd}) to test loadable_extension_embedded ${dummy_c_host_extension} vtable (embedded within C-based extension)" +actual_vtable_output=$(${sqlite3_cmd} -cmd ".load ${dummy_c_host_extension}" :memory: "SELECT value FROM dummy_embedded LIMIT 1;") +>&2 echo "sqlite3 command returned successfully from vtable test, checking output is as expected" +test "${actual_vtable_output}" = "${expected_vtable_output}" && echo "OK" || (echo "vtable output '${actual_vtable_output}' was not as expected '${expected_vtable_output}'"; echo "FAIL"; exit 1) + +>&2 echo "running sqlite3 (${sqlite3_cmd}) to test loadable_extension_embedded ${dummy_c_host_extension} function (embedded within C-based extension)" +actual_function_output=$(${sqlite3_cmd} -cmd ".load ${dummy_c_host_extension}" :memory: "SELECT dummy_embedded_test_function();") +>&2 echo "sqlite3 command returned successfully from function test, checking output is as expected" +test "${actual_function_output}" = "${expected_function_output}" && echo "OK" || (echo "function output '${actual_function_output}' was not as expected '${expected_function_output}'"; echo "FAIL"; exit 1) + +>&2 echo "All tests passed." +exit 0 diff --git a/dummy-embedded-extension/src/lib.rs b/dummy-embedded-extension/src/lib.rs new file mode 100644 index 000000000..97db0799a --- /dev/null +++ b/dummy-embedded-extension/src/lib.rs @@ -0,0 +1,127 @@ +use std::marker::PhantomData; +use std::os::raw::{c_char, c_int}; + +use rusqlite::vtab::{ + eponymous_only_module, sqlite3_vtab, sqlite3_vtab_cursor, Context, IndexInfo, VTab, + VTabConnection, VTabCursor, Values, +}; +use rusqlite::{ + ffi, + functions::FunctionFlags, + types::{ToSqlOutput, Value}, +}; +use rusqlite::{to_sqlite_error, Connection, Result}; + +/// dummy_embedded_extension_init is the entry point for this library. +/// +/// This crate produces a cdylib that is intended to be embedded within +/// (i.e. linked into) another library that implements the sqlite loadable +/// extension entrypoint. +/// +/// In the case of this example code, refer to the `dummy-c-host-extension` +/// C code to find where this entry point is invoked. +/// +/// Note that this interface is private between the host extension and this +/// library - it can have any signature as long as it passes the *sqlite3 db +/// pointer so we can use it to initialize our rusqlite::Connection. +/// +/// It does *not* have to return sqlite status codes (such as SQLITE_OK), we +/// just do that here to keep the C extension simple. +#[no_mangle] +pub extern "C" fn dummy_embedded_extension_init( + db: *mut ffi::sqlite3, + pz_err_msg: *mut *mut c_char, +) -> c_int { + let res = dummy_embedded_init(db); + if let Err(err) = res { + return unsafe { to_sqlite_error(&err, pz_err_msg) }; + } + + ffi::SQLITE_OK +} + +#[repr(C)] +struct DummyEmbeddedTab { + /// Base class. Must be first + base: sqlite3_vtab, +} + +unsafe impl<'vtab> VTab<'vtab> for DummyEmbeddedTab { + type Aux = (); + type Cursor = DummyEmbeddedTabCursor<'vtab>; + + fn connect( + _: &mut VTabConnection, + _aux: Option<&()>, + _args: &[&[u8]], + ) -> Result<(String, DummyEmbeddedTab)> { + let vtab = DummyEmbeddedTab { + base: sqlite3_vtab::default(), + }; + Ok(("CREATE TABLE x(value TEXT)".to_owned(), vtab)) + } + + fn best_index(&self, info: &mut IndexInfo) -> Result<()> { + info.set_estimated_cost(1.); + Ok(()) + } + + fn open(&'vtab self) -> Result> { + Ok(DummyEmbeddedTabCursor::default()) + } +} + +#[derive(Default)] +#[repr(C)] +struct DummyEmbeddedTabCursor<'vtab> { + /// Base class. Must be first + base: sqlite3_vtab_cursor, + /// The rowid + row_id: i64, + phantom: PhantomData<&'vtab DummyEmbeddedTab>, +} + +unsafe impl VTabCursor for DummyEmbeddedTabCursor<'_> { + fn filter( + &mut self, + _idx_num: c_int, + _idx_str: Option<&str>, + _args: &Values<'_>, + ) -> Result<()> { + self.row_id = 1; + Ok(()) + } + + fn next(&mut self) -> Result<()> { + self.row_id += 1; + Ok(()) + } + + fn eof(&self) -> bool { + self.row_id > 1 + } + + fn column(&self, ctx: &mut Context, _: c_int) -> Result<()> { + ctx.set_result(&"dummy_embedded_test_value".to_string()) + } + + fn rowid(&self) -> Result { + Ok(self.row_id) + } +} + +fn dummy_embedded_init(db: *mut ffi::sqlite3) -> Result<()> { + let conn = unsafe { Connection::from_handle(db)? }; + eprintln!("inited dummy embedded extension module {:?}", db); + conn.create_scalar_function( + "dummy_embedded_test_function", + 0, + FunctionFlags::SQLITE_DETERMINISTIC, + |_ctx| { + Ok(ToSqlOutput::Owned(Value::Text( + "Dummy embedded extension loaded correctly!".to_string(), + ))) + }, + )?; + conn.create_module::("dummy_embedded", eponymous_only_module::(), None) +} diff --git a/dummy-extension/Cargo.toml b/dummy-extension/Cargo.toml index b3d68e2de..38386766d 100644 --- a/dummy-extension/Cargo.toml +++ b/dummy-extension/Cargo.toml @@ -4,7 +4,7 @@ version = "0.0.1" authors = ["The rusqlite developers"] edition = "2018" repository = "https://github.com/rusqlite/rusqlite" -description = "Dummy extension" +description = "Dummy extension to demonstrate and test rusqlite feature loadable_extension" license = "MIT" keywords = ["sqlite", "extension"] diff --git a/dummy-extension/integration-test.sh b/dummy-extension/integration-test.sh index b1707622c..41a6fce32 100755 --- a/dummy-extension/integration-test.sh +++ b/dummy-extension/integration-test.sh @@ -2,14 +2,36 @@ set -euf -o pipefail +# the crate dir is where this script is located +crate_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" + +# location of the cdylib extension within the target dir +dummy_extension="${crate_dir}/target/debug/libdummy_extension" # sqlite will try adding .so, .dll, .dylib to this on its own + +# expected output from vtable query +expected_vtable_output="1" + +# expected output from function query +expected_function_output="Dummy extension loaded correctly!" + +>&2 echo "checking for sqlite3 shell" sqlite3_cmd=$(which sqlite3) -dummy_extension="dummy-extension/target/debug/libdummy_extension" # sqlite will try adding .so, .dll, .dylib to this on its own +>&2 echo "sqlite3 found: ${sqlite3_cmd}" + +# build the dummy-extension crate +>&2 echo "building the dummy-extension crate in ${crate_dir}" +(cd "${crate_dir}" && cargo build --all-targets --verbose) +>&2 echo "successfully built the dummy-extension crate" ->&2 echo "running sqlite3 (${sqlite3_cmd}) to test loadable extension ${dummy_extension}" -output=$(sqlite3 -cmd ".load ${dummy_extension}" :memory: "SELECT value FROM dummy") +>&2 echo "running sqlite3 (${sqlite3_cmd}) to test loadable_extension ${dummy_extension} vtable" +actual_vtable_output=$(${sqlite3_cmd} -cmd ".load ${dummy_extension}" :memory: "SELECT value FROM dummy LIMIT 1;") +>&2 echo "sqlite3 command returned successfully from vtable test, checking output is as expected" +test "${actual_vtable_output}" = "${expected_vtable_output}" && echo "OK" || (echo "vtable output '${actual_vtable_output}' was not as expected '${expected_vtable_output}'"; echo "FAIL"; exit 1) ->&2 echo "sqlite3 command returned output, checking it is as expected" -test "1" = "${output}" +>&2 echo "running sqlite3 (${sqlite3_cmd}) to test loadable_extension ${dummy_extension} function" +actual_function_output=$(${sqlite3_cmd} -cmd ".load ${dummy_extension}" :memory: "SELECT dummy_test_function();") +>&2 echo "sqlite3 command returned successfully from function test, checking output is as expected" +test "${actual_function_output}" = "${expected_function_output}" && echo "OK" || (echo "function output '${actual_function_output}' was not as expected '${expected_function_output}'"; echo "FAIL"; exit 1) ->&2 echo "OK" +>&2 echo "All tests passed." exit 0 diff --git a/dummy-extension/src/lib.rs b/dummy-extension/src/lib.rs index d76d1802f..597b2f53a 100644 --- a/dummy-extension/src/lib.rs +++ b/dummy-extension/src/lib.rs @@ -110,7 +110,7 @@ fn dummy_init(db: *mut ffi::sqlite3) -> Result<()> { FunctionFlags::SQLITE_DETERMINISTIC, |_ctx| { Ok(ToSqlOutput::Owned(Value::Text( - "Loaded correctly!".to_string(), + "Dummy extension loaded correctly!".to_string(), ))) }, )?; From 568dfea4d7fd5227128f4e7889488f6d20592208 Mon Sep 17 00:00:00 2001 From: "Joshua C. Randall" Date: Wed, 8 Dec 2021 15:31:38 +0000 Subject: [PATCH 50/61] rename dummy-extension and dummy-embedded-extension to example-extension and example-embedded-extension --- .github/workflows/main.yml | 14 +++---- dummy-embedded-extension/.gitignore | 3 -- example-embedded-extension/.gitignore | 3 ++ .../Cargo.toml | 4 +- .../build.rs | 2 +- .../example_c_host_extension.c | 6 +-- .../integration-test.sh | 32 +++++++-------- .../src/lib.rs | 40 +++++++++---------- .../.gitignore | 0 .../Cargo.toml | 4 +- .../integration-test.sh | 18 ++++----- .../src/lib.rs | 32 +++++++-------- 12 files changed, 79 insertions(+), 79 deletions(-) delete mode 100644 dummy-embedded-extension/.gitignore create mode 100644 example-embedded-extension/.gitignore rename {dummy-embedded-extension => example-embedded-extension}/Cargo.toml (75%) rename {dummy-embedded-extension => example-embedded-extension}/build.rs (86%) rename dummy-embedded-extension/dummy-c-host-extension/dummy_c_host_extension.c => example-embedded-extension/example-c-host-extension/example_c_host_extension.c (83%) rename {dummy-embedded-extension => example-embedded-extension}/integration-test.sh (53%) rename {dummy-embedded-extension => example-embedded-extension}/src/lib.rs (67%) rename {dummy-extension => example-extension}/.gitignore (100%) rename {dummy-extension => example-extension}/Cargo.toml (77%) rename {dummy-extension => example-extension}/integration-test.sh (65%) rename {dummy-extension => example-extension}/src/lib.rs (74%) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 9fde808d2..503b7f5c1 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -117,21 +117,21 @@ jobs: - run: cargo build --features sqlcipher --workspace --all-targets --verbose - run: cargo test --features sqlcipher --workspace --all-targets --verbose - dummy-extension: - name: Test loadable_extension with dummy-extension + example-extension: + name: Test loadable_extension with example-extension runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - uses: hecrj/setup-rust-action@v1 - - run: ./dummy-extension/integration-test.sh + - run: ./example-extension/integration-test.sh - dummy-embedded-extension: - name: Test loadable_extension_embedded with dummy-embedded-extension + example-embedded-extension: + name: Test loadable_extension_embedded with example-embedded-extension runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - uses: hecrj/setup-rust-action@v1 - - run: ./dummy-embedded-extension/integration-test.sh + - run: ./example-embedded-extension/integration-test.sh sanitizer: name: Address Sanitizer @@ -167,7 +167,7 @@ jobs: - run: cargo clippy --all-targets --workspace --features bundled -- -D warnings # Clippy with all non-conflicting features - run: cargo clippy --all-targets --workspace --features 'bundled-full session buildtime_bindgen' -- -D warnings - - run: (cd dummy-extension && cargo clippy --all-targets -- -D warnings) + - run: (cd example-extension && cargo clippy --all-targets -- -D warnings) # Ensure patch is formatted. fmt: diff --git a/dummy-embedded-extension/.gitignore b/dummy-embedded-extension/.gitignore deleted file mode 100644 index 2074695f1..000000000 --- a/dummy-embedded-extension/.gitignore +++ /dev/null @@ -1,3 +0,0 @@ -dummy-embedded-extension.h -dummy-c-host-extension/libdummy_c_host_extension.so -target/ diff --git a/example-embedded-extension/.gitignore b/example-embedded-extension/.gitignore new file mode 100644 index 000000000..696b7fe17 --- /dev/null +++ b/example-embedded-extension/.gitignore @@ -0,0 +1,3 @@ +example-embedded-extension.h +example-c-host-extension/libexample_c_host_extension.so +target/ diff --git a/dummy-embedded-extension/Cargo.toml b/example-embedded-extension/Cargo.toml similarity index 75% rename from dummy-embedded-extension/Cargo.toml rename to example-embedded-extension/Cargo.toml index 942d5ff5b..018dd7e7c 100644 --- a/dummy-embedded-extension/Cargo.toml +++ b/example-embedded-extension/Cargo.toml @@ -1,10 +1,10 @@ [package] -name = "dummy-embedded-extension" +name = "example-embedded-extension" version = "0.0.1" authors = ["The rusqlite developers"] edition = "2018" repository = "https://github.com/rusqlite/rusqlite" -description = "Dummy embedded extension to demonstrate and test rusqlite feature loadable_extension_embedded" +description = "Example embedded extension to demonstrate and test rusqlite feature loadable_extension_embedded" license = "MIT" keywords = ["sqlite", "extension"] diff --git a/dummy-embedded-extension/build.rs b/example-embedded-extension/build.rs similarity index 86% rename from dummy-embedded-extension/build.rs rename to example-embedded-extension/build.rs index 4cf0795fa..86450f0ff 100644 --- a/dummy-embedded-extension/build.rs +++ b/example-embedded-extension/build.rs @@ -11,5 +11,5 @@ fn main() { .with_crate(crate_dir) .generate() .expect("Unable to generate bindings") - .write_to_file("dummy-embedded-extension.h"); + .write_to_file("example-embedded-extension.h"); } diff --git a/dummy-embedded-extension/dummy-c-host-extension/dummy_c_host_extension.c b/example-embedded-extension/example-c-host-extension/example_c_host_extension.c similarity index 83% rename from dummy-embedded-extension/dummy-c-host-extension/dummy_c_host_extension.c rename to example-embedded-extension/example-c-host-extension/example_c_host_extension.c index 71f37d234..740a0444e 100644 --- a/dummy-embedded-extension/dummy-c-host-extension/dummy_c_host_extension.c +++ b/example-embedded-extension/example-c-host-extension/example_c_host_extension.c @@ -3,10 +3,10 @@ SQLITE_EXTENSION_INIT1 // include the cbindgen-generated bindings for the embedded extension -#include "dummy-embedded-extension.h" +#include "example-embedded-extension.h" // the extension entry point -int sqlite3_dummychostextension_init( +int sqlite3_examplechostextension_init( sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pApi @@ -16,7 +16,7 @@ int sqlite3_dummychostextension_init( // for this example, we essentially just pass through to the embedded // extension and return the result. - rc = dummy_embedded_extension_init(db, pzErrMsg); + rc = example_embedded_extension_init(db, pzErrMsg); return rc; } diff --git a/dummy-embedded-extension/integration-test.sh b/example-embedded-extension/integration-test.sh similarity index 53% rename from dummy-embedded-extension/integration-test.sh rename to example-embedded-extension/integration-test.sh index 6a876d08d..a43d91d49 100755 --- a/dummy-embedded-extension/integration-test.sh +++ b/example-embedded-extension/integration-test.sh @@ -6,18 +6,18 @@ set -euf -o pipefail crate_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" # location of the cdylib embedded library within the target dir to be embedded within the c host extension -dummy_embedded_extension_lib_dir="${crate_dir}/target/debug" -dummy_embedded_extension_lib="dummy_embedded_extension" +example_embedded_extension_lib_dir="${crate_dir}/target/debug" +example_embedded_extension_lib="example_embedded_extension" # location of the c host extension to be loaded by sqlite -dummy_c_host_extension_dir="${crate_dir}/dummy-c-host-extension" -dummy_c_host_extension="${dummy_c_host_extension_dir}/libdummy_c_host_extension" # sqlite will try adding .so, .dll, .dylib to this on its own +example_c_host_extension_dir="${crate_dir}/example-c-host-extension" +example_c_host_extension="${example_c_host_extension_dir}/libexample_c_host_extension" # sqlite will try adding .so, .dll, .dylib to this on its own # expected output from vtable query -expected_vtable_output="dummy_embedded_test_value" +expected_vtable_output="example_embedded_test_value" # expected output from function query -expected_function_output="Dummy embedded extension loaded correctly!" +expected_function_output="Example embedded extension loaded correctly!" # sqlite3 include dir (location of sqlite3ext.h) - can be set by SQLITE3_INCLUDE_DIR env var or defaults to bundled version sqlite3_include_dir=${SQLITE3_INCLUDE_DIR:-${crate_dir}/../sqlite3} @@ -26,23 +26,23 @@ sqlite3_include_dir=${SQLITE3_INCLUDE_DIR:-${crate_dir}/../sqlite3} sqlite3_cmd=$(which sqlite3) >&2 echo "sqlite3 found: ${sqlite3_cmd}" -# build the dummy-embedded-extension crate ->&2 echo "building the dummy-embedded-extension crate in ${crate_dir}" +# build the example-embedded-extension crate +>&2 echo "building the example-embedded-extension crate in ${crate_dir}" (cd "${crate_dir}" && cargo build --all-targets --verbose) ->&2 echo "successfully built the dummy-embedded-extension crate" +>&2 echo "successfully built the example-embedded-extension crate" # build the C-based host extension ->&2 echo "building the dummy-c-host-extension" -clang -g -fPIC -O2 -shared -I${sqlite3_include_dir} -I${crate_dir} -L${dummy_embedded_extension_lib_dir} -Wl,-rpath,${dummy_embedded_extension_lib_dir} -l${dummy_embedded_extension_lib} ${dummy_c_host_extension_dir}/dummy_c_host_extension.c -o ${dummy_c_host_extension}.so ->&2 echo "successfully built the dummy-c-host-extension" +>&2 echo "building the example-c-host-extension" +clang -g -fPIC -O2 -shared -I${sqlite3_include_dir} -I${crate_dir} -L${example_embedded_extension_lib_dir} -Wl,-rpath,${example_embedded_extension_lib_dir} -l${example_embedded_extension_lib} ${example_c_host_extension_dir}/example_c_host_extension.c -o ${example_c_host_extension}.so +>&2 echo "successfully built the example-c-host-extension" ->&2 echo "running sqlite3 (${sqlite3_cmd}) to test loadable_extension_embedded ${dummy_c_host_extension} vtable (embedded within C-based extension)" -actual_vtable_output=$(${sqlite3_cmd} -cmd ".load ${dummy_c_host_extension}" :memory: "SELECT value FROM dummy_embedded LIMIT 1;") +>&2 echo "running sqlite3 (${sqlite3_cmd}) to test loadable_extension_embedded ${example_c_host_extension} vtable (embedded within C-based extension)" +actual_vtable_output=$(${sqlite3_cmd} -cmd ".load ${example_c_host_extension}" :memory: "SELECT value FROM example_embedded LIMIT 1;") >&2 echo "sqlite3 command returned successfully from vtable test, checking output is as expected" test "${actual_vtable_output}" = "${expected_vtable_output}" && echo "OK" || (echo "vtable output '${actual_vtable_output}' was not as expected '${expected_vtable_output}'"; echo "FAIL"; exit 1) ->&2 echo "running sqlite3 (${sqlite3_cmd}) to test loadable_extension_embedded ${dummy_c_host_extension} function (embedded within C-based extension)" -actual_function_output=$(${sqlite3_cmd} -cmd ".load ${dummy_c_host_extension}" :memory: "SELECT dummy_embedded_test_function();") +>&2 echo "running sqlite3 (${sqlite3_cmd}) to test loadable_extension_embedded ${example_c_host_extension} function (embedded within C-based extension)" +actual_function_output=$(${sqlite3_cmd} -cmd ".load ${example_c_host_extension}" :memory: "SELECT example_embedded_test_function();") >&2 echo "sqlite3 command returned successfully from function test, checking output is as expected" test "${actual_function_output}" = "${expected_function_output}" && echo "OK" || (echo "function output '${actual_function_output}' was not as expected '${expected_function_output}'"; echo "FAIL"; exit 1) diff --git a/dummy-embedded-extension/src/lib.rs b/example-embedded-extension/src/lib.rs similarity index 67% rename from dummy-embedded-extension/src/lib.rs rename to example-embedded-extension/src/lib.rs index 97db0799a..16d3278a5 100644 --- a/dummy-embedded-extension/src/lib.rs +++ b/example-embedded-extension/src/lib.rs @@ -12,13 +12,13 @@ use rusqlite::{ }; use rusqlite::{to_sqlite_error, Connection, Result}; -/// dummy_embedded_extension_init is the entry point for this library. +/// example_embedded_extension_init is the entry point for this library. /// /// This crate produces a cdylib that is intended to be embedded within /// (i.e. linked into) another library that implements the sqlite loadable /// extension entrypoint. /// -/// In the case of this example code, refer to the `dummy-c-host-extension` +/// In the case of this example code, refer to the `example-c-host-extension` /// C code to find where this entry point is invoked. /// /// Note that this interface is private between the host extension and this @@ -28,11 +28,11 @@ use rusqlite::{to_sqlite_error, Connection, Result}; /// It does *not* have to return sqlite status codes (such as SQLITE_OK), we /// just do that here to keep the C extension simple. #[no_mangle] -pub extern "C" fn dummy_embedded_extension_init( +pub extern "C" fn example_embedded_extension_init( db: *mut ffi::sqlite3, pz_err_msg: *mut *mut c_char, ) -> c_int { - let res = dummy_embedded_init(db); + let res = example_embedded_init(db); if let Err(err) = res { return unsafe { to_sqlite_error(&err, pz_err_msg) }; } @@ -41,21 +41,21 @@ pub extern "C" fn dummy_embedded_extension_init( } #[repr(C)] -struct DummyEmbeddedTab { +struct ExampleEmbeddedTab { /// Base class. Must be first base: sqlite3_vtab, } -unsafe impl<'vtab> VTab<'vtab> for DummyEmbeddedTab { +unsafe impl<'vtab> VTab<'vtab> for ExampleEmbeddedTab { type Aux = (); - type Cursor = DummyEmbeddedTabCursor<'vtab>; + type Cursor = ExampleEmbeddedTabCursor<'vtab>; fn connect( _: &mut VTabConnection, _aux: Option<&()>, _args: &[&[u8]], - ) -> Result<(String, DummyEmbeddedTab)> { - let vtab = DummyEmbeddedTab { + ) -> Result<(String, ExampleEmbeddedTab)> { + let vtab = ExampleEmbeddedTab { base: sqlite3_vtab::default(), }; Ok(("CREATE TABLE x(value TEXT)".to_owned(), vtab)) @@ -66,22 +66,22 @@ unsafe impl<'vtab> VTab<'vtab> for DummyEmbeddedTab { Ok(()) } - fn open(&'vtab self) -> Result> { - Ok(DummyEmbeddedTabCursor::default()) + fn open(&'vtab self) -> Result> { + Ok(ExampleEmbeddedTabCursor::default()) } } #[derive(Default)] #[repr(C)] -struct DummyEmbeddedTabCursor<'vtab> { +struct ExampleEmbeddedTabCursor<'vtab> { /// Base class. Must be first base: sqlite3_vtab_cursor, /// The rowid row_id: i64, - phantom: PhantomData<&'vtab DummyEmbeddedTab>, + phantom: PhantomData<&'vtab ExampleEmbeddedTab>, } -unsafe impl VTabCursor for DummyEmbeddedTabCursor<'_> { +unsafe impl VTabCursor for ExampleEmbeddedTabCursor<'_> { fn filter( &mut self, _idx_num: c_int, @@ -102,7 +102,7 @@ unsafe impl VTabCursor for DummyEmbeddedTabCursor<'_> { } fn column(&self, ctx: &mut Context, _: c_int) -> Result<()> { - ctx.set_result(&"dummy_embedded_test_value".to_string()) + ctx.set_result(&"example_embedded_test_value".to_string()) } fn rowid(&self) -> Result { @@ -110,18 +110,18 @@ unsafe impl VTabCursor for DummyEmbeddedTabCursor<'_> { } } -fn dummy_embedded_init(db: *mut ffi::sqlite3) -> Result<()> { +fn example_embedded_init(db: *mut ffi::sqlite3) -> Result<()> { let conn = unsafe { Connection::from_handle(db)? }; - eprintln!("inited dummy embedded extension module {:?}", db); + eprintln!("inited example embedded extension module {:?}", db); conn.create_scalar_function( - "dummy_embedded_test_function", + "example_embedded_test_function", 0, FunctionFlags::SQLITE_DETERMINISTIC, |_ctx| { Ok(ToSqlOutput::Owned(Value::Text( - "Dummy embedded extension loaded correctly!".to_string(), + "Example embedded extension loaded correctly!".to_string(), ))) }, )?; - conn.create_module::("dummy_embedded", eponymous_only_module::(), None) + conn.create_module::("example_embedded", eponymous_only_module::(), None) } diff --git a/dummy-extension/.gitignore b/example-extension/.gitignore similarity index 100% rename from dummy-extension/.gitignore rename to example-extension/.gitignore diff --git a/dummy-extension/Cargo.toml b/example-extension/Cargo.toml similarity index 77% rename from dummy-extension/Cargo.toml rename to example-extension/Cargo.toml index 38386766d..28a43b38f 100644 --- a/dummy-extension/Cargo.toml +++ b/example-extension/Cargo.toml @@ -1,10 +1,10 @@ [package] -name = "dummy-extension" +name = "example-extension" version = "0.0.1" authors = ["The rusqlite developers"] edition = "2018" repository = "https://github.com/rusqlite/rusqlite" -description = "Dummy extension to demonstrate and test rusqlite feature loadable_extension" +description = "Example extension to demonstrate and test rusqlite feature loadable_extension" license = "MIT" keywords = ["sqlite", "extension"] diff --git a/dummy-extension/integration-test.sh b/example-extension/integration-test.sh similarity index 65% rename from dummy-extension/integration-test.sh rename to example-extension/integration-test.sh index 41a6fce32..6bb924e7c 100755 --- a/dummy-extension/integration-test.sh +++ b/example-extension/integration-test.sh @@ -6,30 +6,30 @@ set -euf -o pipefail crate_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" # location of the cdylib extension within the target dir -dummy_extension="${crate_dir}/target/debug/libdummy_extension" # sqlite will try adding .so, .dll, .dylib to this on its own +example_extension="${crate_dir}/target/debug/libexample_extension" # sqlite will try adding .so, .dll, .dylib to this on its own # expected output from vtable query expected_vtable_output="1" # expected output from function query -expected_function_output="Dummy extension loaded correctly!" +expected_function_output="Example extension loaded correctly!" >&2 echo "checking for sqlite3 shell" sqlite3_cmd=$(which sqlite3) >&2 echo "sqlite3 found: ${sqlite3_cmd}" -# build the dummy-extension crate ->&2 echo "building the dummy-extension crate in ${crate_dir}" +# build the example-extension crate +>&2 echo "building the example-extension crate in ${crate_dir}" (cd "${crate_dir}" && cargo build --all-targets --verbose) ->&2 echo "successfully built the dummy-extension crate" +>&2 echo "successfully built the example-extension crate" ->&2 echo "running sqlite3 (${sqlite3_cmd}) to test loadable_extension ${dummy_extension} vtable" -actual_vtable_output=$(${sqlite3_cmd} -cmd ".load ${dummy_extension}" :memory: "SELECT value FROM dummy LIMIT 1;") +>&2 echo "running sqlite3 (${sqlite3_cmd}) to test loadable_extension ${example_extension} vtable" +actual_vtable_output=$(${sqlite3_cmd} -cmd ".load ${example_extension}" :memory: "SELECT value FROM example LIMIT 1;") >&2 echo "sqlite3 command returned successfully from vtable test, checking output is as expected" test "${actual_vtable_output}" = "${expected_vtable_output}" && echo "OK" || (echo "vtable output '${actual_vtable_output}' was not as expected '${expected_vtable_output}'"; echo "FAIL"; exit 1) ->&2 echo "running sqlite3 (${sqlite3_cmd}) to test loadable_extension ${dummy_extension} function" -actual_function_output=$(${sqlite3_cmd} -cmd ".load ${dummy_extension}" :memory: "SELECT dummy_test_function();") +>&2 echo "running sqlite3 (${sqlite3_cmd}) to test loadable_extension ${example_extension} function" +actual_function_output=$(${sqlite3_cmd} -cmd ".load ${example_extension}" :memory: "SELECT example_test_function();") >&2 echo "sqlite3 command returned successfully from function test, checking output is as expected" test "${actual_function_output}" = "${expected_function_output}" && echo "OK" || (echo "function output '${actual_function_output}' was not as expected '${expected_function_output}'"; echo "FAIL"; exit 1) diff --git a/dummy-extension/src/lib.rs b/example-extension/src/lib.rs similarity index 74% rename from dummy-extension/src/lib.rs rename to example-extension/src/lib.rs index 597b2f53a..0d4b30d91 100644 --- a/dummy-extension/src/lib.rs +++ b/example-extension/src/lib.rs @@ -23,7 +23,7 @@ pub extern "C" fn sqlite3_extension_init( unsafe { ffi::sqlite3_api = p_api; } - let res = dummy_init(db); + let res = example_init(db); if let Err(err) = res { return unsafe { to_sqlite_error(&err, pz_err_msg) }; } @@ -32,21 +32,21 @@ pub extern "C" fn sqlite3_extension_init( } #[repr(C)] -struct DummyTab { +struct ExampleTab { /// Base class. Must be first base: sqlite3_vtab, } -unsafe impl<'vtab> VTab<'vtab> for DummyTab { +unsafe impl<'vtab> VTab<'vtab> for ExampleTab { type Aux = (); - type Cursor = DummyTabCursor<'vtab>; + type Cursor = ExampleTabCursor<'vtab>; fn connect( _: &mut VTabConnection, _aux: Option<&()>, _args: &[&[u8]], - ) -> Result<(String, DummyTab)> { - let vtab = DummyTab { + ) -> Result<(String, ExampleTab)> { + let vtab = ExampleTab { base: sqlite3_vtab::default(), }; Ok(("CREATE TABLE x(value)".to_owned(), vtab)) @@ -57,22 +57,22 @@ unsafe impl<'vtab> VTab<'vtab> for DummyTab { Ok(()) } - fn open(&'vtab self) -> Result> { - Ok(DummyTabCursor::default()) + fn open(&'vtab self) -> Result> { + Ok(ExampleTabCursor::default()) } } #[derive(Default)] #[repr(C)] -struct DummyTabCursor<'vtab> { +struct ExampleTabCursor<'vtab> { /// Base class. Must be first base: sqlite3_vtab_cursor, /// The rowid row_id: i64, - phantom: PhantomData<&'vtab DummyTab>, + phantom: PhantomData<&'vtab ExampleTab>, } -unsafe impl VTabCursor for DummyTabCursor<'_> { +unsafe impl VTabCursor for ExampleTabCursor<'_> { fn filter( &mut self, _idx_num: c_int, @@ -101,18 +101,18 @@ unsafe impl VTabCursor for DummyTabCursor<'_> { } } -fn dummy_init(db: *mut ffi::sqlite3) -> Result<()> { +fn example_init(db: *mut ffi::sqlite3) -> Result<()> { let conn = unsafe { Connection::from_handle(db)? }; - eprintln!("inited dummy module {:?}", db); + eprintln!("inited example module {:?}", db); conn.create_scalar_function( - "dummy_test_function", + "example_test_function", 0, FunctionFlags::SQLITE_DETERMINISTIC, |_ctx| { Ok(ToSqlOutput::Owned(Value::Text( - "Dummy extension loaded correctly!".to_string(), + "Example extension loaded correctly!".to_string(), ))) }, )?; - conn.create_module::("dummy", eponymous_only_module::(), None) + conn.create_module::("example", eponymous_only_module::(), None) } From 462ff150c0d101ee0df0ec337a3e36dfd64dd9cd Mon Sep 17 00:00:00 2001 From: "Joshua C. Randall" Date: Wed, 8 Dec 2021 16:23:52 +0000 Subject: [PATCH 51/61] fix issues resulting from merge conflict resolution in libsqlite3-sys/build.rs --- libsqlite3-sys/Cargo.toml | 8 +++----- libsqlite3-sys/build.rs | 13 +++++++------ 2 files changed, 10 insertions(+), 11 deletions(-) diff --git a/libsqlite3-sys/Cargo.toml b/libsqlite3-sys/Cargo.toml index 7fc154469..1e79fe446 100644 --- a/libsqlite3-sys/Cargo.toml +++ b/libsqlite3-sys/Cargo.toml @@ -45,11 +45,9 @@ openssl-sys = { version = "0.9", optional = true } [build-dependencies] bindgen = { version = "0.59", optional = true, default-features = false, features = ["runtime"] } -pkg-config = { version = "0.3.19", optional = true } cc = { version = "1.0", optional = true } -syn = { version = "1.0", features = ["extra-traits", "full", "printing"], optional = true } +pkg-config = { version = "0.3.19", optional = true } quote = { version = "1.0", optional = true } -which = { version = "4.0.2", optional = true } - -[target.'cfg(target_env = "msvc")'.build-dependencies] +syn = { version = "1.0", features = ["extra-traits", "full", "printing"], optional = true } vcpkg = { version = "0.2", optional = true } +which = { version = "4.0.2", optional = true } diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index 4dae20b1b..179f82371 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -48,11 +48,9 @@ fn main() { or 'bundled-sqlcipher-vendored-openssl' to also bundle OpenSSL crypto." ) } - build_linked::main(&out_dir, &out_path); - return; + build_linked::main(&out_dir, &out_path) } else if cfg!(feature = "loadable_extension") { - build_loadable_extension::main(&out_dir, &out_path); - return; + build_loadable_extension::main(&out_dir, &out_path) } else if cfg!(feature = "bundled") || (win_target() && cfg!(feature = "bundled-windows")) || cfg!(feature = "bundled-sqlcipher") @@ -96,7 +94,8 @@ mod build_bundled { #[cfg(feature = "buildtime_bindgen")] { use super::{bindings, header_file, HeaderLocation}; - let header = HeaderLocation::FromPath(format!("{}/{}", lib_name, header_file())); + let header_path = format!("{}/{}", lib_name, header_file()); + let header = HeaderLocation::FromPath(header_path); bindings::write_to_out_dir(header, out_path); println!("cargo:rerun-if-changed={}", header_path); } @@ -332,8 +331,10 @@ fn wrapper_file() -> &'static str { "wrapper-ext.h" } else { "wrapper.h" + } +} - fn lib_name() -> &'static str { +fn lib_name() -> &'static str { if cfg!(any(feature = "sqlcipher", feature = "bundled-sqlcipher")) { "sqlcipher" } else if cfg!(all(windows, feature = "winsqlite3")) { From f87a94cbadf330a09b4a6310f365a6dcfe4874c0 Mon Sep 17 00:00:00 2001 From: "Joshua C. Randall" Date: Wed, 8 Dec 2021 16:59:04 +0000 Subject: [PATCH 52/61] fix issue with header_path in libsqlite3-sys/build.rs correct clippy::needless-borrow issue in to_sqlite_error function in src/error.rs --- libsqlite3-sys/build.rs | 4 ++-- src/error.rs | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index 179f82371..34262fbfb 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -95,9 +95,9 @@ mod build_bundled { { use super::{bindings, header_file, HeaderLocation}; let header_path = format!("{}/{}", lib_name, header_file()); - let header = HeaderLocation::FromPath(header_path); + let header = HeaderLocation::FromPath(header_path.clone()); bindings::write_to_out_dir(header, out_path); - println!("cargo:rerun-if-changed={}", header_path); + println!("cargo:rerun-if-changed={}", &header_path); } #[cfg(not(feature = "buildtime_bindgen"))] { diff --git a/src/error.rs b/src/error.rs index b81cc5682..d34857b11 100644 --- a/src/error.rs +++ b/src/error.rs @@ -375,7 +375,7 @@ pub unsafe fn to_sqlite_error( match e { Error::SqliteFailure(err, s) => { if let Some(s) = s { - *err_msg = crate::util::SqliteMallocString::from_str(&s).into_raw(); + *err_msg = crate::util::SqliteMallocString::from_str(s).into_raw(); } err.extended_code } From a2ac5f28f1d8b53fcf71038cc56394ddd2f7a12f Mon Sep 17 00:00:00 2001 From: "Joshua C. Randall" Date: Wed, 8 Dec 2021 17:52:13 +0000 Subject: [PATCH 53/61] don't specify version in example-*/Cargo.toml so that they can be built against the current source tree --- example-embedded-extension/Cargo.toml | 1 - example-extension/Cargo.toml | 1 - 2 files changed, 2 deletions(-) diff --git a/example-embedded-extension/Cargo.toml b/example-embedded-extension/Cargo.toml index 018dd7e7c..ee3fcaa1a 100644 --- a/example-embedded-extension/Cargo.toml +++ b/example-embedded-extension/Cargo.toml @@ -17,7 +17,6 @@ crate-type = ["cdylib"] path = ".." default-features = false features = ["loadable_extension_embedded", "vtab", "functions", "bundled"] -version = "0.24.2" [build-dependencies] cbindgen = "0.18.0" diff --git a/example-extension/Cargo.toml b/example-extension/Cargo.toml index 28a43b38f..7be7b9aa1 100644 --- a/example-extension/Cargo.toml +++ b/example-extension/Cargo.toml @@ -17,7 +17,6 @@ crate-type = ["cdylib"] path = ".." default-features = false features = ["loadable_extension", "vtab", "functions", "bundled"] -version = "0.24.2" [workspace] members = [] From 0c50fd39f429953dc9a80b8aa4477874e74baf6b Mon Sep 17 00:00:00 2001 From: "Joshua C. Randall" Date: Wed, 8 Dec 2021 18:21:21 +0000 Subject: [PATCH 54/61] cargo fmt --- libsqlite3-sys/build.rs | 4 +++- src/config.rs | 8 ++++---- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index 34262fbfb..002678323 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -375,7 +375,9 @@ mod build_linked { #[cfg(feature = "vcpkg")] extern crate vcpkg; - use super::{bindings, env_prefix, header_file, is_compiler, lib_name, win_target, HeaderLocation}; + use super::{ + bindings, env_prefix, header_file, is_compiler, lib_name, win_target, HeaderLocation, + }; use std::env; use std::path::Path; diff --git a/src/config.rs b/src/config.rs index fb11c0007..be7e16eb1 100644 --- a/src/config.rs +++ b/src/config.rs @@ -86,14 +86,14 @@ impl Connection { c.db(), config as c_int, -1, - &mut val + &mut val, ))?; #[cfg(feature = "loadable_extension")] check(ffi::sqlite3_db_config_int_mutint( c.db(), config as c_int, -1, - &mut val + &mut val, ))?; Ok(val != 0) } @@ -123,14 +123,14 @@ impl Connection { c.db(), config as c_int, if new_val { 1 } else { 0 }, - &mut val + &mut val, ))?; #[cfg(feature = "loadable_extension")] check(ffi::sqlite3_db_config_int_mutint( c.db(), config as c_int, if new_val { 1 } else { 0 }, - &mut val + &mut val, ))?; Ok(val != 0) } From 2472ec98c89c9db4a66e59625054ebabb2b83d30 Mon Sep 17 00:00:00 2001 From: "Joshua C. Randall" Date: Wed, 8 Dec 2021 23:25:26 +0000 Subject: [PATCH 55/61] remove extraneous cmoment line in libsqlite3-sys/build.rs --- libsqlite3-sys/build.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index 002678323..68cd7151b 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -1019,7 +1019,6 @@ use crate::sqlite3_api; // transparently wrap variadic api functions. // generate specific set of args in place of // variadic for each function we care about. - // functions we don't handle will have match api_fn_name { "sqlite3_db_config" => { // https://sqlite.org/c3ref/c_dbconfig_defensive.html From 50694746dc9abaf54ef237d61ac75f2bc7eefc10 Mon Sep 17 00:00:00 2001 From: "Joshua C. Randall" Date: Wed, 8 Dec 2021 23:53:25 +0000 Subject: [PATCH 56/61] add runtime version checks to loadable extension wrappers, improve safety, and add explicit entry points for both embedded and non-embedded loadable extensions --- .../integration-test.sh | 2 +- example-embedded-extension/src/lib.rs | 7 +- example-extension/src/lib.rs | 11 +- libsqlite3-sys/Cargo.toml | 8 +- .../bindgen-bindings/bindgen_3.6.23-ext.rs | 1305 ++++---- .../bindgen-bindings/bindgen_3.6.8-ext.rs | 1303 ++++---- .../bindgen-bindings/bindgen_3.7.16-ext.rs | 1920 +++++++---- .../bindgen-bindings/bindgen_3.7.7-ext.rs | 1665 ++++++---- libsqlite3-sys/build.rs | 282 +- .../sqlite3/bindgen_bundled_version-ext.rs | 2941 ++++++++++++----- libsqlite3-sys/src/lib.rs | 27 +- libsqlite3-sys/src/loadable_extension.rs | 160 + libsqlite3-sys/upgrade.sh | 2 +- 13 files changed, 6151 insertions(+), 3482 deletions(-) create mode 100644 libsqlite3-sys/src/loadable_extension.rs diff --git a/example-embedded-extension/integration-test.sh b/example-embedded-extension/integration-test.sh index a43d91d49..092e0c37d 100755 --- a/example-embedded-extension/integration-test.sh +++ b/example-embedded-extension/integration-test.sh @@ -20,7 +20,7 @@ expected_vtable_output="example_embedded_test_value" expected_function_output="Example embedded extension loaded correctly!" # sqlite3 include dir (location of sqlite3ext.h) - can be set by SQLITE3_INCLUDE_DIR env var or defaults to bundled version -sqlite3_include_dir=${SQLITE3_INCLUDE_DIR:-${crate_dir}/../sqlite3} +sqlite3_include_dir=${SQLITE3_INCLUDE_DIR:-${crate_dir}/../libsqlite3-sys/sqlite3} >&2 echo "checking for sqlite3 shell" sqlite3_cmd=$(which sqlite3) diff --git a/example-embedded-extension/src/lib.rs b/example-embedded-extension/src/lib.rs index 16d3278a5..f0da152b9 100644 --- a/example-embedded-extension/src/lib.rs +++ b/example-embedded-extension/src/lib.rs @@ -1,3 +1,4 @@ +use crate::ffi::loadable_extension_embedded_init; // required feature `loadable_extension_embedded` use std::marker::PhantomData; use std::os::raw::{c_char, c_int}; @@ -28,13 +29,15 @@ use rusqlite::{to_sqlite_error, Connection, Result}; /// It does *not* have to return sqlite status codes (such as SQLITE_OK), we /// just do that here to keep the C extension simple. #[no_mangle] -pub extern "C" fn example_embedded_extension_init( +pub unsafe extern "C" fn example_embedded_extension_init( db: *mut ffi::sqlite3, pz_err_msg: *mut *mut c_char, ) -> c_int { + loadable_extension_embedded_init(); + let res = example_embedded_init(db); if let Err(err) = res { - return unsafe { to_sqlite_error(&err, pz_err_msg) }; + return to_sqlite_error(&err, pz_err_msg); } ffi::SQLITE_OK diff --git a/example-extension/src/lib.rs b/example-extension/src/lib.rs index 0d4b30d91..3f375de6a 100644 --- a/example-extension/src/lib.rs +++ b/example-extension/src/lib.rs @@ -1,3 +1,4 @@ +use crate::ffi::loadable_extension_init; use std::marker::PhantomData; use std::os::raw::{c_char, c_int}; @@ -14,18 +15,18 @@ use rusqlite::{to_sqlite_error, Connection, Result}; #[allow(clippy::not_unsafe_ptr_arg_deref)] #[no_mangle] -pub extern "C" fn sqlite3_extension_init( +pub unsafe extern "C" fn sqlite3_extension_init( db: *mut ffi::sqlite3, pz_err_msg: *mut *mut c_char, p_api: *mut ffi::sqlite3_api_routines, ) -> c_int { // SQLITE_EXTENSION_INIT2 equivalent - unsafe { - ffi::sqlite3_api = p_api; - } + loadable_extension_init(p_api); + + // initialize example virtual table let res = example_init(db); if let Err(err) = res { - return unsafe { to_sqlite_error(&err, pz_err_msg) }; + return to_sqlite_error(&err, pz_err_msg); } ffi::SQLITE_OK diff --git a/libsqlite3-sys/Cargo.toml b/libsqlite3-sys/Cargo.toml index 1e79fe446..f8a1655dd 100644 --- a/libsqlite3-sys/Cargo.toml +++ b/libsqlite3-sys/Cargo.toml @@ -18,8 +18,8 @@ bundled-windows = ["cc", "bundled_bindings"] bundled-sqlcipher = ["bundled"] bundled-sqlcipher-vendored-openssl = ["bundled-sqlcipher", "openssl-sys/vendored"] buildtime_bindgen = ["bindgen", "pkg-config", "vcpkg"] -loadable_extension = ["syn", "quote", "which"] -loadable_extension_embedded = ["loadable_extension"] +loadable_extension = ["proc-macro2", "regex", "syn", "quote", "version-compare", "which"] +loadable_extension_embedded = ["loadable_extension", "lazy_static"] sqlcipher = [] min_sqlite_version_3_6_8 = ["pkg-config", "vcpkg"] min_sqlite_version_3_6_23 = ["pkg-config", "vcpkg"] @@ -41,13 +41,17 @@ wasm32-wasi-vfs = [] winsqlite3 = ["min_sqlite_version_3_7_16"] [dependencies] +lazy_static = { version = "1.4", optional = true } openssl-sys = { version = "0.9", optional = true } [build-dependencies] bindgen = { version = "0.59", optional = true, default-features = false, features = ["runtime"] } cc = { version = "1.0", optional = true } pkg-config = { version = "0.3.19", optional = true } +proc-macro2 = { version = "1.0", optional = true } quote = { version = "1.0", optional = true } +regex = { version = "1.5", optional = true } syn = { version = "1.0", features = ["extra-traits", "full", "printing"], optional = true } vcpkg = { version = "0.2", optional = true } +version-compare = { version = "0.1", optional = true } which = { version = "4.0.2", optional = true } diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23-ext.rs index 65ddca3fc..6c29a0c65 100644 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23-ext.rs +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.23-ext.rs @@ -1,9 +1,9 @@ -/* automatically generated by rust-bindgen 0.57.0 */ +/* automatically generated by rust-bindgen 0.59.2 */ pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.6.23\0"; +pub const SQLITE_VERSION: &[u8; 7usize] = b"3.6.23\0"; pub const SQLITE_VERSION_NUMBER: i32 = 3006023; -pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = +pub const SQLITE_SOURCE_ID: &[u8; 61usize] = b"2010-03-09 19:31:43 4ae453ea7be69018d8c16eb8dabe05617397dc4d\0"; pub const SQLITE_OK: i32 = 0; pub const SQLITE_ERROR: i32 = 1; @@ -4673,19 +4673,20 @@ fn bindgen_test_layout___va_list_tag() { ); } -// sqlite3_api is defined in lib.rs as either a static or an extern when compiled as a loadable_extension -use crate::sqlite3_api; +// The `loadable_extension_sqlite3_api` function is defined when compiled as a +// loadable_extension. It is used to safely access the static `SQLITE3_API` +// reference that is populated by a call to either`loadable_extension_init` +// or `loadable_extension_embedded_init` +use crate::loadable_extension_sqlite3_api; -// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from libsqlite3-sys/build.rs - not by rust-bindgen) pub unsafe fn sqlite3_aggregate_context( arg1: *mut sqlite3_context, nBytes: ::std::os::raw::c_int, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_context.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).aggregate_context.expect(stringify!( "sqlite3_api contains null pointer for ", "aggregate_context", " function" @@ -4693,10 +4694,8 @@ pub unsafe fn sqlite3_aggregate_context( } pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_count.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).aggregate_count.expect(stringify!( "sqlite3_api contains null pointer for ", "aggregate_count", " function" @@ -4710,10 +4709,8 @@ pub unsafe fn sqlite3_bind_blob( n: ::std::os::raw::c_int, arg4: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_blob.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_blob.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_blob", " function" @@ -4725,10 +4722,8 @@ pub unsafe fn sqlite3_bind_double( arg2: ::std::os::raw::c_int, arg3: f64, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_double.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_double.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_double", " function" @@ -4740,10 +4735,8 @@ pub unsafe fn sqlite3_bind_int( arg2: ::std::os::raw::c_int, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_int.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_int", " function" @@ -4755,10 +4748,8 @@ pub unsafe fn sqlite3_bind_int64( arg2: ::std::os::raw::c_int, arg3: sqlite_int64, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int64.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_int64.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_int64", " function" @@ -4769,10 +4760,8 @@ pub unsafe fn sqlite3_bind_null( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_null.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_null.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_null", " function" @@ -4780,10 +4769,8 @@ pub unsafe fn sqlite3_bind_null( } pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_count.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_parameter_count.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_parameter_count", " function" @@ -4794,10 +4781,8 @@ pub unsafe fn sqlite3_bind_parameter_index( arg1: *mut sqlite3_stmt, zName: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_index.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_parameter_index.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_parameter_index", " function" @@ -4808,10 +4793,8 @@ pub unsafe fn sqlite3_bind_parameter_name( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_name.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_parameter_name.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_parameter_name", " function" @@ -4825,10 +4808,8 @@ pub unsafe fn sqlite3_bind_text( n: ::std::os::raw::c_int, arg4: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_text.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_text", " function" @@ -4842,10 +4823,8 @@ pub unsafe fn sqlite3_bind_text16( arg4: ::std::os::raw::c_int, arg5: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_text16.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_text16", " function" @@ -4857,10 +4836,8 @@ pub unsafe fn sqlite3_bind_value( arg2: ::std::os::raw::c_int, arg3: *const sqlite3_value, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_value.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_value.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_value", " function" @@ -4877,10 +4854,8 @@ pub unsafe fn sqlite3_busy_handler( >, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_handler.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).busy_handler.expect(stringify!( "sqlite3_api contains null pointer for ", "busy_handler", " function" @@ -4891,10 +4866,8 @@ pub unsafe fn sqlite3_busy_timeout( arg1: *mut sqlite3, ms: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_timeout.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).busy_timeout.expect(stringify!( "sqlite3_api contains null pointer for ", "busy_timeout", " function" @@ -4902,10 +4875,8 @@ pub unsafe fn sqlite3_busy_timeout( } pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).changes.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).changes.expect(stringify!( "sqlite3_api contains null pointer for ", "changes", " function" @@ -4913,10 +4884,8 @@ pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { } pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).close.expect(stringify!( "sqlite3_api contains null pointer for ", "close", " function" @@ -4935,10 +4904,8 @@ pub unsafe fn sqlite3_collation_needed( ), >, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).collation_needed.expect(stringify!( "sqlite3_api contains null pointer for ", "collation_needed", " function" @@ -4957,10 +4924,8 @@ pub unsafe fn sqlite3_collation_needed16( ), >, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).collation_needed16.expect(stringify!( "sqlite3_api contains null pointer for ", "collation_needed16", " function" @@ -4971,10 +4936,8 @@ pub unsafe fn sqlite3_column_blob( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_blob.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_blob.expect(stringify!( "sqlite3_api contains null pointer for ", "column_blob", " function" @@ -4985,10 +4948,8 @@ pub unsafe fn sqlite3_column_bytes( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_bytes.expect(stringify!( "sqlite3_api contains null pointer for ", "column_bytes", " function" @@ -4999,10 +4960,8 @@ pub unsafe fn sqlite3_column_bytes16( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_bytes16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_bytes16", " function" @@ -5010,10 +4969,8 @@ pub unsafe fn sqlite3_column_bytes16( } pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_count.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_count.expect(stringify!( "sqlite3_api contains null pointer for ", "column_count", " function" @@ -5024,10 +4981,8 @@ pub unsafe fn sqlite3_column_database_name( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_database_name.expect(stringify!( "sqlite3_api contains null pointer for ", "column_database_name", " function" @@ -5038,10 +4993,8 @@ pub unsafe fn sqlite3_column_database_name16( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_database_name16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_database_name16", " function" @@ -5052,10 +5005,8 @@ pub unsafe fn sqlite3_column_decltype( arg1: *mut sqlite3_stmt, i: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_decltype.expect(stringify!( "sqlite3_api contains null pointer for ", "column_decltype", " function" @@ -5066,10 +5017,8 @@ pub unsafe fn sqlite3_column_decltype16( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_decltype16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_decltype16", " function" @@ -5077,10 +5026,8 @@ pub unsafe fn sqlite3_column_decltype16( } pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_double.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_double.expect(stringify!( "sqlite3_api contains null pointer for ", "column_double", " function" @@ -5091,10 +5038,8 @@ pub unsafe fn sqlite3_column_int( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_int.expect(stringify!( "sqlite3_api contains null pointer for ", "column_int", " function" @@ -5105,10 +5050,8 @@ pub unsafe fn sqlite3_column_int64( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int64.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_int64.expect(stringify!( "sqlite3_api contains null pointer for ", "column_int64", " function" @@ -5119,10 +5062,8 @@ pub unsafe fn sqlite3_column_name( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_name.expect(stringify!( "sqlite3_api contains null pointer for ", "column_name", " function" @@ -5133,10 +5074,8 @@ pub unsafe fn sqlite3_column_name16( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_name16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_name16", " function" @@ -5147,10 +5086,8 @@ pub unsafe fn sqlite3_column_origin_name( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_origin_name.expect(stringify!( "sqlite3_api contains null pointer for ", "column_origin_name", " function" @@ -5161,10 +5098,8 @@ pub unsafe fn sqlite3_column_origin_name16( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_origin_name16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_origin_name16", " function" @@ -5175,10 +5110,8 @@ pub unsafe fn sqlite3_column_table_name( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_table_name.expect(stringify!( "sqlite3_api contains null pointer for ", "column_table_name", " function" @@ -5189,10 +5122,8 @@ pub unsafe fn sqlite3_column_table_name16( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_table_name16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_table_name16", " function" @@ -5203,10 +5134,8 @@ pub unsafe fn sqlite3_column_text( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_text.expect(stringify!( "sqlite3_api contains null pointer for ", "column_text", " function" @@ -5217,10 +5146,8 @@ pub unsafe fn sqlite3_column_text16( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_text16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_text16", " function" @@ -5231,10 +5158,8 @@ pub unsafe fn sqlite3_column_type( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_type.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_type.expect(stringify!( "sqlite3_api contains null pointer for ", "column_type", " function" @@ -5245,10 +5170,8 @@ pub unsafe fn sqlite3_column_value( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_value.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_value.expect(stringify!( "sqlite3_api contains null pointer for ", "column_value", " function" @@ -5262,10 +5185,8 @@ pub unsafe fn sqlite3_commit_hook( >, arg3: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).commit_hook.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).commit_hook.expect(stringify!( "sqlite3_api contains null pointer for ", "commit_hook", " function" @@ -5273,10 +5194,8 @@ pub unsafe fn sqlite3_commit_hook( } pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).complete.expect(stringify!( "sqlite3_api contains null pointer for ", "complete", " function" @@ -5284,10 +5203,8 @@ pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os: } pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).complete16.expect(stringify!( "sqlite3_api contains null pointer for ", "complete16", " function" @@ -5309,10 +5226,8 @@ pub unsafe fn sqlite3_create_collation( ) -> ::std::os::raw::c_int, >, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).create_collation.expect(stringify!( "sqlite3_api contains null pointer for ", "create_collation", " function" @@ -5334,10 +5249,8 @@ pub unsafe fn sqlite3_create_collation16( ) -> ::std::os::raw::c_int, >, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).create_collation16.expect(stringify!( "sqlite3_api contains null pointer for ", "create_collation16", " function" @@ -5366,10 +5279,8 @@ pub unsafe fn sqlite3_create_function( >, xFinal: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).create_function.expect(stringify!( "sqlite3_api contains null pointer for ", "create_function", " function" @@ -5398,10 +5309,8 @@ pub unsafe fn sqlite3_create_function16( >, xFinal: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).create_function16.expect(stringify!( "sqlite3_api contains null pointer for ", "create_function16", " function" @@ -5414,10 +5323,8 @@ pub unsafe fn sqlite3_create_module( arg3: *const sqlite3_module, arg4: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).create_module.expect(stringify!( "sqlite3_api contains null pointer for ", "create_module", " function" @@ -5425,10 +5332,8 @@ pub unsafe fn sqlite3_create_module( } pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).data_count.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).data_count.expect(stringify!( "sqlite3_api contains null pointer for ", "data_count", " function" @@ -5436,10 +5341,8 @@ pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_ } pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_handle.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).db_handle.expect(stringify!( "sqlite3_api contains null pointer for ", "db_handle", " function" @@ -5450,10 +5353,8 @@ pub unsafe fn sqlite3_declare_vtab( arg1: *mut sqlite3, arg2: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).declare_vtab.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).declare_vtab.expect(stringify!( "sqlite3_api contains null pointer for ", "declare_vtab", " function" @@ -5461,10 +5362,8 @@ pub unsafe fn sqlite3_declare_vtab( } pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).enable_shared_cache.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).enable_shared_cache.expect(stringify!( "sqlite3_api contains null pointer for ", "enable_shared_cache", " function" @@ -5472,10 +5371,8 @@ pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std: } pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errcode.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).errcode.expect(stringify!( "sqlite3_api contains null pointer for ", "errcode", " function" @@ -5483,10 +5380,8 @@ pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { } pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).errmsg.expect(stringify!( "sqlite3_api contains null pointer for ", "errmsg", " function" @@ -5494,10 +5389,8 @@ pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_cha } pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).errmsg16.expect(stringify!( "sqlite3_api contains null pointer for ", "errmsg16", " function" @@ -5511,10 +5404,8 @@ pub unsafe fn sqlite3_exec( arg4: *mut ::std::os::raw::c_void, arg5: *mut *mut ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).exec.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).exec.expect(stringify!( "sqlite3_api contains null pointer for ", "exec", " function" @@ -5522,10 +5413,8 @@ pub unsafe fn sqlite3_exec( } pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).expired.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).expired.expect(stringify!( "sqlite3_api contains null pointer for ", "expired", " function" @@ -5533,10 +5422,8 @@ pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int } pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).finalize.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).finalize.expect(stringify!( "sqlite3_api contains null pointer for ", "finalize", " function" @@ -5544,10 +5431,8 @@ pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_in } pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).free.expect(stringify!( "sqlite3_api contains null pointer for ", "free", " function" @@ -5555,10 +5440,8 @@ pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { } pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free_table.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).free_table.expect(stringify!( "sqlite3_api contains null pointer for ", "free_table", " function" @@ -5566,10 +5449,8 @@ pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { } pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_autocommit.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).get_autocommit.expect(stringify!( "sqlite3_api contains null pointer for ", "get_autocommit", " function" @@ -5580,10 +5461,8 @@ pub unsafe fn sqlite3_get_auxdata( arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_auxdata.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).get_auxdata.expect(stringify!( "sqlite3_api contains null pointer for ", "get_auxdata", " function" @@ -5598,10 +5477,8 @@ pub unsafe fn sqlite3_get_table( arg5: *mut ::std::os::raw::c_int, arg6: *mut *mut ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_table.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).get_table.expect(stringify!( "sqlite3_api contains null pointer for ", "get_table", " function" @@ -5609,10 +5486,8 @@ pub unsafe fn sqlite3_get_table( } pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).global_recover.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).global_recover.expect(stringify!( "sqlite3_api contains null pointer for ", "global_recover", " function" @@ -5620,10 +5495,8 @@ pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { } pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).interruptx.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).interruptx.expect(stringify!( "sqlite3_api contains null pointer for ", "interruptx", " function" @@ -5631,10 +5504,8 @@ pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { } pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).last_insert_rowid.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).last_insert_rowid.expect(stringify!( "sqlite3_api contains null pointer for ", "last_insert_rowid", " function" @@ -5642,10 +5513,8 @@ pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { } pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).libversion.expect(stringify!( "sqlite3_api contains null pointer for ", "libversion", " function" @@ -5653,10 +5522,8 @@ pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { } pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion_number.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).libversion_number.expect(stringify!( "sqlite3_api contains null pointer for ", "libversion_number", " function" @@ -5664,10 +5531,8 @@ pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { } pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).malloc.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).malloc.expect(stringify!( "sqlite3_api contains null pointer for ", "malloc", " function" @@ -5675,10 +5540,8 @@ pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw } pub unsafe fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mprintf.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).mprintf.expect(stringify!( "sqlite3_api contains null pointer for ", "mprintf", " function" @@ -5689,10 +5552,8 @@ pub unsafe fn sqlite3_open( arg1: *const ::std::os::raw::c_char, arg2: *mut *mut sqlite3, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).open.expect(stringify!( "sqlite3_api contains null pointer for ", "open", " function" @@ -5703,10 +5564,8 @@ pub unsafe fn sqlite3_open16( arg1: *const ::std::os::raw::c_void, arg2: *mut *mut sqlite3, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).open16.expect(stringify!( "sqlite3_api contains null pointer for ", "open16", " function" @@ -5720,10 +5579,8 @@ pub unsafe fn sqlite3_prepare( arg4: *mut *mut sqlite3_stmt, arg5: *mut *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).prepare.expect(stringify!( "sqlite3_api contains null pointer for ", "prepare", " function" @@ -5737,10 +5594,8 @@ pub unsafe fn sqlite3_prepare16( arg4: *mut *mut sqlite3_stmt, arg5: *mut *const ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).prepare16.expect(stringify!( "sqlite3_api contains null pointer for ", "prepare16", " function" @@ -5758,10 +5613,8 @@ pub unsafe fn sqlite3_profile( >, arg3: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).profile.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).profile.expect(stringify!( "sqlite3_api contains null pointer for ", "profile", " function" @@ -5776,10 +5629,8 @@ pub unsafe fn sqlite3_progress_handler( >, arg4: *mut ::std::os::raw::c_void, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).progress_handler.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).progress_handler.expect(stringify!( "sqlite3_api contains null pointer for ", "progress_handler", " function" @@ -5790,10 +5641,8 @@ pub unsafe fn sqlite3_realloc( arg1: *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).realloc.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).realloc.expect(stringify!( "sqlite3_api contains null pointer for ", "realloc", " function" @@ -5801,10 +5650,8 @@ pub unsafe fn sqlite3_realloc( } pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).reset.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).reset.expect(stringify!( "sqlite3_api contains null pointer for ", "reset", " function" @@ -5817,10 +5664,8 @@ pub unsafe fn sqlite3_result_blob( arg3: ::std::os::raw::c_int, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_blob.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_blob.expect(stringify!( "sqlite3_api contains null pointer for ", "result_blob", " function" @@ -5828,10 +5673,8 @@ pub unsafe fn sqlite3_result_blob( } pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_double.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_double.expect(stringify!( "sqlite3_api contains null pointer for ", "result_double", " function" @@ -5843,10 +5686,8 @@ pub unsafe fn sqlite3_result_error( arg2: *const ::std::os::raw::c_char, arg3: ::std::os::raw::c_int, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_error.expect(stringify!( "sqlite3_api contains null pointer for ", "result_error", " function" @@ -5858,10 +5699,8 @@ pub unsafe fn sqlite3_result_error16( arg2: *const ::std::os::raw::c_void, arg3: ::std::os::raw::c_int, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_error16.expect(stringify!( "sqlite3_api contains null pointer for ", "result_error16", " function" @@ -5869,10 +5708,8 @@ pub unsafe fn sqlite3_result_error16( } pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_int.expect(stringify!( "sqlite3_api contains null pointer for ", "result_int", " function" @@ -5880,10 +5717,8 @@ pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::ra } pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int64.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_int64.expect(stringify!( "sqlite3_api contains null pointer for ", "result_int64", " function" @@ -5891,10 +5726,8 @@ pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int6 } pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_null.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_null.expect(stringify!( "sqlite3_api contains null pointer for ", "result_null", " function" @@ -5907,10 +5740,8 @@ pub unsafe fn sqlite3_result_text( arg3: ::std::os::raw::c_int, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_text.expect(stringify!( "sqlite3_api contains null pointer for ", "result_text", " function" @@ -5923,10 +5754,8 @@ pub unsafe fn sqlite3_result_text16( arg3: ::std::os::raw::c_int, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_text16.expect(stringify!( "sqlite3_api contains null pointer for ", "result_text16", " function" @@ -5939,10 +5768,8 @@ pub unsafe fn sqlite3_result_text16be( arg3: ::std::os::raw::c_int, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16be.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_text16be.expect(stringify!( "sqlite3_api contains null pointer for ", "result_text16be", " function" @@ -5955,10 +5782,8 @@ pub unsafe fn sqlite3_result_text16le( arg3: ::std::os::raw::c_int, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16le.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_text16le.expect(stringify!( "sqlite3_api contains null pointer for ", "result_text16le", " function" @@ -5966,10 +5791,8 @@ pub unsafe fn sqlite3_result_text16le( } pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_value.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_value.expect(stringify!( "sqlite3_api contains null pointer for ", "result_value", " function" @@ -5981,10 +5804,8 @@ pub unsafe fn sqlite3_rollback_hook( arg2: ::std::option::Option, arg3: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).rollback_hook.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).rollback_hook.expect(stringify!( "sqlite3_api contains null pointer for ", "rollback_hook", " function" @@ -6005,10 +5826,8 @@ pub unsafe fn sqlite3_set_authorizer( >, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_authorizer.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).set_authorizer.expect(stringify!( "sqlite3_api contains null pointer for ", "set_authorizer", " function" @@ -6021,10 +5840,8 @@ pub unsafe fn sqlite3_set_auxdata( arg3: *mut ::std::os::raw::c_void, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_auxdata.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).set_auxdata.expect(stringify!( "sqlite3_api contains null pointer for ", "set_auxdata", " function" @@ -6036,10 +5853,8 @@ pub unsafe fn sqlite3_snprintf( arg2: *mut ::std::os::raw::c_char, arg3: *const ::std::os::raw::c_char, ) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).snprintf.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).snprintf.expect(stringify!( "sqlite3_api contains null pointer for ", "snprintf", " function" @@ -6047,10 +5862,8 @@ pub unsafe fn sqlite3_snprintf( } pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).step.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).step.expect(stringify!( "sqlite3_api contains null pointer for ", "step", " function" @@ -6068,10 +5881,8 @@ pub unsafe fn sqlite3_table_column_metadata( arg8: *mut ::std::os::raw::c_int, arg9: *mut ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).table_column_metadata.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).table_column_metadata.expect(stringify!( "sqlite3_api contains null pointer for ", "table_column_metadata", " function" @@ -6079,10 +5890,8 @@ pub unsafe fn sqlite3_table_column_metadata( } pub unsafe fn sqlite3_thread_cleanup() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).thread_cleanup.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).thread_cleanup.expect(stringify!( "sqlite3_api contains null pointer for ", "thread_cleanup", " function" @@ -6090,10 +5899,8 @@ pub unsafe fn sqlite3_thread_cleanup() { } pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).total_changes.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).total_changes.expect(stringify!( "sqlite3_api contains null pointer for ", "total_changes", " function" @@ -6110,10 +5917,8 @@ pub unsafe fn sqlite3_trace( >, arg2: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).trace.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).trace.expect(stringify!( "sqlite3_api contains null pointer for ", "trace", " function" @@ -6124,10 +5929,8 @@ pub unsafe fn sqlite3_transfer_bindings( arg1: *mut sqlite3_stmt, arg2: *mut sqlite3_stmt, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).transfer_bindings.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).transfer_bindings.expect(stringify!( "sqlite3_api contains null pointer for ", "transfer_bindings", " function" @@ -6147,10 +5950,8 @@ pub unsafe fn sqlite3_update_hook( >, arg3: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).update_hook.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).update_hook.expect(stringify!( "sqlite3_api contains null pointer for ", "update_hook", " function" @@ -6158,10 +5959,8 @@ pub unsafe fn sqlite3_update_hook( } pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).user_data.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).user_data.expect(stringify!( "sqlite3_api contains null pointer for ", "user_data", " function" @@ -6169,10 +5968,8 @@ pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::r } pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_blob.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_blob.expect(stringify!( "sqlite3_api contains null pointer for ", "value_blob", " function" @@ -6180,10 +5977,8 @@ pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os:: } pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_bytes.expect(stringify!( "sqlite3_api contains null pointer for ", "value_bytes", " function" @@ -6191,10 +5986,8 @@ pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c } pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_bytes16.expect(stringify!( "sqlite3_api contains null pointer for ", "value_bytes16", " function" @@ -6202,10 +5995,8 @@ pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw: } pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_double.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_double.expect(stringify!( "sqlite3_api contains null pointer for ", "value_double", " function" @@ -6213,10 +6004,8 @@ pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { } pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_int.expect(stringify!( "sqlite3_api contains null pointer for ", "value_int", " function" @@ -6224,10 +6013,8 @@ pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_i } pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int64.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_int64.expect(stringify!( "sqlite3_api contains null pointer for ", "value_int64", " function" @@ -6235,10 +6022,8 @@ pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { } pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_numeric_type.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_numeric_type.expect(stringify!( "sqlite3_api contains null pointer for ", "value_numeric_type", " function" @@ -6246,10 +6031,8 @@ pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os: } pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_text.expect(stringify!( "sqlite3_api contains null pointer for ", "value_text", " function" @@ -6257,10 +6040,8 @@ pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os:: } pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_text16.expect(stringify!( "sqlite3_api contains null pointer for ", "value_text16", " function" @@ -6268,10 +6049,8 @@ pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os } pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16be.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_text16be.expect(stringify!( "sqlite3_api contains null pointer for ", "value_text16be", " function" @@ -6279,10 +6058,8 @@ pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std:: } pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16le.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_text16le.expect(stringify!( "sqlite3_api contains null pointer for ", "value_text16le", " function" @@ -6290,10 +6067,8 @@ pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std:: } pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_type.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_type.expect(stringify!( "sqlite3_api contains null pointer for ", "value_type", " function" @@ -6304,10 +6079,8 @@ pub unsafe fn sqlite3_vmprintf( arg1: *const ::std::os::raw::c_char, arg2: *mut __va_list_tag, ) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vmprintf.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).vmprintf.expect(stringify!( "sqlite3_api contains null pointer for ", "vmprintf", " function" @@ -6319,10 +6092,19 @@ pub unsafe fn sqlite3_overload_function( zFuncName: *const ::std::os::raw::c_char, nArg: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3003013i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_overload_function, + " function" + ), + sqlite3_version_number, 3003013i32 + ); } - ((*sqlite3_api).overload_function.expect(stringify!( + ((*p_api).overload_function.expect(stringify!( "sqlite3_api contains null pointer for ", "overload_function", " function" @@ -6336,10 +6118,19 @@ pub unsafe fn sqlite3_prepare_v2( arg4: *mut *mut sqlite3_stmt, arg5: *mut *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3003013i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_prepare_v2, + " function" + ), + sqlite3_version_number, 3003013i32 + ); } - ((*sqlite3_api).prepare_v2.expect(stringify!( + ((*p_api).prepare_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "prepare_v2", " function" @@ -6353,10 +6144,19 @@ pub unsafe fn sqlite3_prepare16_v2( arg4: *mut *mut sqlite3_stmt, arg5: *mut *const ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3003013i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_prepare16_v2, + " function" + ), + sqlite3_version_number, 3003013i32 + ); } - ((*sqlite3_api).prepare16_v2.expect(stringify!( + ((*p_api).prepare16_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "prepare16_v2", " function" @@ -6364,10 +6164,19 @@ pub unsafe fn sqlite3_prepare16_v2( } pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3003013i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_clear_bindings, + " function" + ), + sqlite3_version_number, 3003013i32 + ); } - ((*sqlite3_api).clear_bindings.expect(stringify!( + ((*p_api).clear_bindings.expect(stringify!( "sqlite3_api contains null pointer for ", "clear_bindings", " function" @@ -6381,10 +6190,19 @@ pub unsafe fn sqlite3_create_module_v2( arg4: *mut ::std::os::raw::c_void, xDestroy: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3004001i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_create_module_v2, + " function" + ), + sqlite3_version_number, 3004001i32 + ); } - ((*sqlite3_api).create_module_v2.expect(stringify!( + ((*p_api).create_module_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "create_module_v2", " function" @@ -6396,10 +6214,19 @@ pub unsafe fn sqlite3_bind_zeroblob( arg2: ::std::os::raw::c_int, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_bind_zeroblob, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).bind_zeroblob.expect(stringify!( + ((*p_api).bind_zeroblob.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_zeroblob", " function" @@ -6407,10 +6234,19 @@ pub unsafe fn sqlite3_bind_zeroblob( } pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_bytes, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_bytes.expect(stringify!( + ((*p_api).blob_bytes.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_bytes", " function" @@ -6418,10 +6254,19 @@ pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_i } pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_close, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_close.expect(stringify!( + ((*p_api).blob_close.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_close", " function" @@ -6437,10 +6282,19 @@ pub unsafe fn sqlite3_blob_open( arg6: ::std::os::raw::c_int, arg7: *mut *mut sqlite3_blob, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_open, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_open.expect(stringify!( + ((*p_api).blob_open.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_open", " function" @@ -6453,10 +6307,19 @@ pub unsafe fn sqlite3_blob_read( arg3: ::std::os::raw::c_int, arg4: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_read, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_read.expect(stringify!( + ((*p_api).blob_read.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_read", " function" @@ -6469,10 +6332,19 @@ pub unsafe fn sqlite3_blob_write( arg3: ::std::os::raw::c_int, arg4: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_write, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_write.expect(stringify!( + ((*p_api).blob_write.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_write", " function" @@ -6495,10 +6367,19 @@ pub unsafe fn sqlite3_create_collation_v2( >, arg6: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_create_collation_v2, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).create_collation_v2.expect(stringify!( + ((*p_api).create_collation_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "create_collation_v2", " function" @@ -6511,10 +6392,19 @@ pub unsafe fn sqlite3_file_control( arg3: ::std::os::raw::c_int, arg4: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_file_control, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).file_control.expect(stringify!( + ((*p_api).file_control.expect(stringify!( "sqlite3_api contains null pointer for ", "file_control", " function" @@ -6522,10 +6412,19 @@ pub unsafe fn sqlite3_file_control( } pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_memory_highwater, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).memory_highwater.expect(stringify!( + ((*p_api).memory_highwater.expect(stringify!( "sqlite3_api contains null pointer for ", "memory_highwater", " function" @@ -6533,10 +6432,19 @@ pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_i } pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_memory_used, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).memory_used.expect(stringify!( + ((*p_api).memory_used.expect(stringify!( "sqlite3_api contains null pointer for ", "memory_used", " function" @@ -6544,10 +6452,19 @@ pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { } pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_mutex_alloc, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).mutex_alloc.expect(stringify!( + ((*p_api).mutex_alloc.expect(stringify!( "sqlite3_api contains null pointer for ", "mutex_alloc", " function" @@ -6555,10 +6472,19 @@ pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_m } pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_mutex_enter, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).mutex_enter.expect(stringify!( + ((*p_api).mutex_enter.expect(stringify!( "sqlite3_api contains null pointer for ", "mutex_enter", " function" @@ -6566,10 +6492,19 @@ pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { } pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_mutex_free, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).mutex_free.expect(stringify!( + ((*p_api).mutex_free.expect(stringify!( "sqlite3_api contains null pointer for ", "mutex_free", " function" @@ -6577,10 +6512,19 @@ pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { } pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_mutex_leave, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).mutex_leave.expect(stringify!( + ((*p_api).mutex_leave.expect(stringify!( "sqlite3_api contains null pointer for ", "mutex_leave", " function" @@ -6588,10 +6532,19 @@ pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { } pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_mutex_try, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).mutex_try.expect(stringify!( + ((*p_api).mutex_try.expect(stringify!( "sqlite3_api contains null pointer for ", "mutex_try", " function" @@ -6604,10 +6557,19 @@ pub unsafe fn sqlite3_open_v2( arg3: ::std::os::raw::c_int, arg4: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_open_v2, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).open_v2.expect(stringify!( + ((*p_api).open_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "open_v2", " function" @@ -6615,10 +6577,19 @@ pub unsafe fn sqlite3_open_v2( } pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_release_memory, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).release_memory.expect(stringify!( + ((*p_api).release_memory.expect(stringify!( "sqlite3_api contains null pointer for ", "release_memory", " function" @@ -6626,10 +6597,19 @@ pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os:: } pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_result_error_nomem, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).result_error_nomem.expect(stringify!( + ((*p_api).result_error_nomem.expect(stringify!( "sqlite3_api contains null pointer for ", "result_error_nomem", " function" @@ -6637,10 +6617,19 @@ pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { } pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_result_error_toobig, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).result_error_toobig.expect(stringify!( + ((*p_api).result_error_toobig.expect(stringify!( "sqlite3_api contains null pointer for ", "result_error_toobig", " function" @@ -6648,10 +6637,19 @@ pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { } pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_sleep, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).sleep.expect(stringify!( + ((*p_api).sleep.expect(stringify!( "sqlite3_api contains null pointer for ", "sleep", " function" @@ -6659,10 +6657,19 @@ pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_in } pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_soft_heap_limit, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).soft_heap_limit.expect(stringify!( + ((*p_api).soft_heap_limit.expect(stringify!( "sqlite3_api contains null pointer for ", "soft_heap_limit", " function" @@ -6670,10 +6677,19 @@ pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { } pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_vfs_find, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).vfs_find.expect(stringify!( + ((*p_api).vfs_find.expect(stringify!( "sqlite3_api contains null pointer for ", "vfs_find", " function" @@ -6684,10 +6700,19 @@ pub unsafe fn sqlite3_vfs_register( arg1: *mut sqlite3_vfs, arg2: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_vfs_register, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).vfs_register.expect(stringify!( + ((*p_api).vfs_register.expect(stringify!( "sqlite3_api contains null pointer for ", "vfs_register", " function" @@ -6695,10 +6720,19 @@ pub unsafe fn sqlite3_vfs_register( } pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_vfs_unregister, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).vfs_unregister.expect(stringify!( + ((*p_api).vfs_unregister.expect(stringify!( "sqlite3_api contains null pointer for ", "vfs_unregister", " function" @@ -6706,10 +6740,19 @@ pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw:: } pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_xthreadsafe, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).xthreadsafe.expect(stringify!( + ((*p_api).xthreadsafe.expect(stringify!( "sqlite3_api contains null pointer for ", "xthreadsafe", " function" @@ -6717,10 +6760,19 @@ pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { } pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_result_zeroblob, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).result_zeroblob.expect(stringify!( + ((*p_api).result_zeroblob.expect(stringify!( "sqlite3_api contains null pointer for ", "result_zeroblob", " function" @@ -6728,10 +6780,19 @@ pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::o } pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_result_error_code, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).result_error_code.expect(stringify!( + ((*p_api).result_error_code.expect(stringify!( "sqlite3_api contains null pointer for ", "result_error_code", " function" @@ -6739,10 +6800,19 @@ pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std: } pub unsafe fn sqlite3_test_control(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_test_control, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).test_control.expect(stringify!( + ((*p_api).test_control.expect(stringify!( "sqlite3_api contains null pointer for ", "test_control", " function" @@ -6750,10 +6820,19 @@ pub unsafe fn sqlite3_test_control(arg1: ::std::os::raw::c_int) -> ::std::os::ra } pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_randomness, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).randomness.expect(stringify!( + ((*p_api).randomness.expect(stringify!( "sqlite3_api contains null pointer for ", "randomness", " function" @@ -6761,10 +6840,19 @@ pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std:: } pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_context_db_handle, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).context_db_handle.expect(stringify!( + ((*p_api).context_db_handle.expect(stringify!( "sqlite3_api contains null pointer for ", "context_db_handle", " function" @@ -6775,10 +6863,19 @@ pub unsafe fn sqlite3_extended_result_codes( arg1: *mut sqlite3, arg2: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_extended_result_codes, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).extended_result_codes.expect(stringify!( + ((*p_api).extended_result_codes.expect(stringify!( "sqlite3_api contains null pointer for ", "extended_result_codes", " function" @@ -6790,10 +6887,19 @@ pub unsafe fn sqlite3_limit( arg2: ::std::os::raw::c_int, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_limit, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).limit.expect(stringify!( + ((*p_api).limit.expect(stringify!( "sqlite3_api contains null pointer for ", "limit", " function" @@ -6801,10 +6907,19 @@ pub unsafe fn sqlite3_limit( } pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_next_stmt, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).next_stmt.expect(stringify!( + ((*p_api).next_stmt.expect(stringify!( "sqlite3_api contains null pointer for ", "next_stmt", " function" @@ -6812,10 +6927,19 @@ pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> } pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_sql, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).sql.expect(stringify!( + ((*p_api).sql.expect(stringify!( "sqlite3_api contains null pointer for ", "sql", " function" @@ -6828,10 +6952,19 @@ pub unsafe fn sqlite3_status( arg3: *mut ::std::os::raw::c_int, arg4: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_status, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).status.expect(stringify!( + ((*p_api).status.expect(stringify!( "sqlite3_api contains null pointer for ", "status", " function" diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs index cd9c2b5d3..d7c0fb544 100644 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.6.8-ext.rs @@ -1,7 +1,7 @@ -/* automatically generated by rust-bindgen 0.57.0 */ +/* automatically generated by rust-bindgen 0.59.2 */ pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 6usize] = b"3.6.8\0"; +pub const SQLITE_VERSION: &[u8; 6usize] = b"3.6.8\0"; pub const SQLITE_VERSION_NUMBER: i32 = 3006008; pub const SQLITE_OK: i32 = 0; pub const SQLITE_ERROR: i32 = 1; @@ -4651,19 +4651,20 @@ fn bindgen_test_layout___va_list_tag() { ); } -// sqlite3_api is defined in lib.rs as either a static or an extern when compiled as a loadable_extension -use crate::sqlite3_api; +// The `loadable_extension_sqlite3_api` function is defined when compiled as a +// loadable_extension. It is used to safely access the static `SQLITE3_API` +// reference that is populated by a call to either`loadable_extension_init` +// or `loadable_extension_embedded_init` +use crate::loadable_extension_sqlite3_api; -// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from libsqlite3-sys/build.rs - not by rust-bindgen) pub unsafe fn sqlite3_aggregate_context( arg1: *mut sqlite3_context, nBytes: ::std::os::raw::c_int, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_context.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).aggregate_context.expect(stringify!( "sqlite3_api contains null pointer for ", "aggregate_context", " function" @@ -4671,10 +4672,8 @@ pub unsafe fn sqlite3_aggregate_context( } pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_count.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).aggregate_count.expect(stringify!( "sqlite3_api contains null pointer for ", "aggregate_count", " function" @@ -4688,10 +4687,8 @@ pub unsafe fn sqlite3_bind_blob( n: ::std::os::raw::c_int, arg4: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_blob.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_blob.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_blob", " function" @@ -4703,10 +4700,8 @@ pub unsafe fn sqlite3_bind_double( arg2: ::std::os::raw::c_int, arg3: f64, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_double.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_double.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_double", " function" @@ -4718,10 +4713,8 @@ pub unsafe fn sqlite3_bind_int( arg2: ::std::os::raw::c_int, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_int.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_int", " function" @@ -4733,10 +4726,8 @@ pub unsafe fn sqlite3_bind_int64( arg2: ::std::os::raw::c_int, arg3: sqlite_int64, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int64.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_int64.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_int64", " function" @@ -4747,10 +4738,8 @@ pub unsafe fn sqlite3_bind_null( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_null.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_null.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_null", " function" @@ -4758,10 +4747,8 @@ pub unsafe fn sqlite3_bind_null( } pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_count.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_parameter_count.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_parameter_count", " function" @@ -4772,10 +4759,8 @@ pub unsafe fn sqlite3_bind_parameter_index( arg1: *mut sqlite3_stmt, zName: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_index.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_parameter_index.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_parameter_index", " function" @@ -4786,10 +4771,8 @@ pub unsafe fn sqlite3_bind_parameter_name( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_name.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_parameter_name.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_parameter_name", " function" @@ -4803,10 +4786,8 @@ pub unsafe fn sqlite3_bind_text( n: ::std::os::raw::c_int, arg4: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_text.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_text", " function" @@ -4820,10 +4801,8 @@ pub unsafe fn sqlite3_bind_text16( arg4: ::std::os::raw::c_int, arg5: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_text16.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_text16", " function" @@ -4835,10 +4814,8 @@ pub unsafe fn sqlite3_bind_value( arg2: ::std::os::raw::c_int, arg3: *const sqlite3_value, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_value.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_value.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_value", " function" @@ -4855,10 +4832,8 @@ pub unsafe fn sqlite3_busy_handler( >, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_handler.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).busy_handler.expect(stringify!( "sqlite3_api contains null pointer for ", "busy_handler", " function" @@ -4869,10 +4844,8 @@ pub unsafe fn sqlite3_busy_timeout( arg1: *mut sqlite3, ms: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_timeout.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).busy_timeout.expect(stringify!( "sqlite3_api contains null pointer for ", "busy_timeout", " function" @@ -4880,10 +4853,8 @@ pub unsafe fn sqlite3_busy_timeout( } pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).changes.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).changes.expect(stringify!( "sqlite3_api contains null pointer for ", "changes", " function" @@ -4891,10 +4862,8 @@ pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { } pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).close.expect(stringify!( "sqlite3_api contains null pointer for ", "close", " function" @@ -4913,10 +4882,8 @@ pub unsafe fn sqlite3_collation_needed( ), >, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).collation_needed.expect(stringify!( "sqlite3_api contains null pointer for ", "collation_needed", " function" @@ -4935,10 +4902,8 @@ pub unsafe fn sqlite3_collation_needed16( ), >, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).collation_needed16.expect(stringify!( "sqlite3_api contains null pointer for ", "collation_needed16", " function" @@ -4949,10 +4914,8 @@ pub unsafe fn sqlite3_column_blob( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_blob.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_blob.expect(stringify!( "sqlite3_api contains null pointer for ", "column_blob", " function" @@ -4963,10 +4926,8 @@ pub unsafe fn sqlite3_column_bytes( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_bytes.expect(stringify!( "sqlite3_api contains null pointer for ", "column_bytes", " function" @@ -4977,10 +4938,8 @@ pub unsafe fn sqlite3_column_bytes16( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_bytes16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_bytes16", " function" @@ -4988,10 +4947,8 @@ pub unsafe fn sqlite3_column_bytes16( } pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_count.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_count.expect(stringify!( "sqlite3_api contains null pointer for ", "column_count", " function" @@ -5002,10 +4959,8 @@ pub unsafe fn sqlite3_column_database_name( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_database_name.expect(stringify!( "sqlite3_api contains null pointer for ", "column_database_name", " function" @@ -5016,10 +4971,8 @@ pub unsafe fn sqlite3_column_database_name16( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_database_name16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_database_name16", " function" @@ -5030,10 +4983,8 @@ pub unsafe fn sqlite3_column_decltype( arg1: *mut sqlite3_stmt, i: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_decltype.expect(stringify!( "sqlite3_api contains null pointer for ", "column_decltype", " function" @@ -5044,10 +4995,8 @@ pub unsafe fn sqlite3_column_decltype16( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_decltype16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_decltype16", " function" @@ -5055,10 +5004,8 @@ pub unsafe fn sqlite3_column_decltype16( } pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_double.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_double.expect(stringify!( "sqlite3_api contains null pointer for ", "column_double", " function" @@ -5069,10 +5016,8 @@ pub unsafe fn sqlite3_column_int( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_int.expect(stringify!( "sqlite3_api contains null pointer for ", "column_int", " function" @@ -5083,10 +5028,8 @@ pub unsafe fn sqlite3_column_int64( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int64.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_int64.expect(stringify!( "sqlite3_api contains null pointer for ", "column_int64", " function" @@ -5097,10 +5040,8 @@ pub unsafe fn sqlite3_column_name( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_name.expect(stringify!( "sqlite3_api contains null pointer for ", "column_name", " function" @@ -5111,10 +5052,8 @@ pub unsafe fn sqlite3_column_name16( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_name16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_name16", " function" @@ -5125,10 +5064,8 @@ pub unsafe fn sqlite3_column_origin_name( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_origin_name.expect(stringify!( "sqlite3_api contains null pointer for ", "column_origin_name", " function" @@ -5139,10 +5076,8 @@ pub unsafe fn sqlite3_column_origin_name16( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_origin_name16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_origin_name16", " function" @@ -5153,10 +5088,8 @@ pub unsafe fn sqlite3_column_table_name( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_table_name.expect(stringify!( "sqlite3_api contains null pointer for ", "column_table_name", " function" @@ -5167,10 +5100,8 @@ pub unsafe fn sqlite3_column_table_name16( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_table_name16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_table_name16", " function" @@ -5181,10 +5112,8 @@ pub unsafe fn sqlite3_column_text( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_text.expect(stringify!( "sqlite3_api contains null pointer for ", "column_text", " function" @@ -5195,10 +5124,8 @@ pub unsafe fn sqlite3_column_text16( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_text16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_text16", " function" @@ -5209,10 +5136,8 @@ pub unsafe fn sqlite3_column_type( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_type.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_type.expect(stringify!( "sqlite3_api contains null pointer for ", "column_type", " function" @@ -5223,10 +5148,8 @@ pub unsafe fn sqlite3_column_value( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_value.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_value.expect(stringify!( "sqlite3_api contains null pointer for ", "column_value", " function" @@ -5240,10 +5163,8 @@ pub unsafe fn sqlite3_commit_hook( >, arg3: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).commit_hook.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).commit_hook.expect(stringify!( "sqlite3_api contains null pointer for ", "commit_hook", " function" @@ -5251,10 +5172,8 @@ pub unsafe fn sqlite3_commit_hook( } pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).complete.expect(stringify!( "sqlite3_api contains null pointer for ", "complete", " function" @@ -5262,10 +5181,8 @@ pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os: } pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).complete16.expect(stringify!( "sqlite3_api contains null pointer for ", "complete16", " function" @@ -5287,10 +5204,8 @@ pub unsafe fn sqlite3_create_collation( ) -> ::std::os::raw::c_int, >, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).create_collation.expect(stringify!( "sqlite3_api contains null pointer for ", "create_collation", " function" @@ -5312,10 +5227,8 @@ pub unsafe fn sqlite3_create_collation16( ) -> ::std::os::raw::c_int, >, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).create_collation16.expect(stringify!( "sqlite3_api contains null pointer for ", "create_collation16", " function" @@ -5344,10 +5257,8 @@ pub unsafe fn sqlite3_create_function( >, xFinal: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).create_function.expect(stringify!( "sqlite3_api contains null pointer for ", "create_function", " function" @@ -5376,10 +5287,8 @@ pub unsafe fn sqlite3_create_function16( >, xFinal: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).create_function16.expect(stringify!( "sqlite3_api contains null pointer for ", "create_function16", " function" @@ -5392,10 +5301,8 @@ pub unsafe fn sqlite3_create_module( arg3: *const sqlite3_module, arg4: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).create_module.expect(stringify!( "sqlite3_api contains null pointer for ", "create_module", " function" @@ -5403,10 +5310,8 @@ pub unsafe fn sqlite3_create_module( } pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).data_count.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).data_count.expect(stringify!( "sqlite3_api contains null pointer for ", "data_count", " function" @@ -5414,10 +5319,8 @@ pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_ } pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_handle.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).db_handle.expect(stringify!( "sqlite3_api contains null pointer for ", "db_handle", " function" @@ -5428,10 +5331,8 @@ pub unsafe fn sqlite3_declare_vtab( arg1: *mut sqlite3, arg2: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).declare_vtab.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).declare_vtab.expect(stringify!( "sqlite3_api contains null pointer for ", "declare_vtab", " function" @@ -5439,10 +5340,8 @@ pub unsafe fn sqlite3_declare_vtab( } pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).enable_shared_cache.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).enable_shared_cache.expect(stringify!( "sqlite3_api contains null pointer for ", "enable_shared_cache", " function" @@ -5450,10 +5349,8 @@ pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std: } pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errcode.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).errcode.expect(stringify!( "sqlite3_api contains null pointer for ", "errcode", " function" @@ -5461,10 +5358,8 @@ pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { } pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).errmsg.expect(stringify!( "sqlite3_api contains null pointer for ", "errmsg", " function" @@ -5472,10 +5367,8 @@ pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_cha } pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).errmsg16.expect(stringify!( "sqlite3_api contains null pointer for ", "errmsg16", " function" @@ -5489,10 +5382,8 @@ pub unsafe fn sqlite3_exec( arg4: *mut ::std::os::raw::c_void, arg5: *mut *mut ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).exec.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).exec.expect(stringify!( "sqlite3_api contains null pointer for ", "exec", " function" @@ -5500,10 +5391,8 @@ pub unsafe fn sqlite3_exec( } pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).expired.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).expired.expect(stringify!( "sqlite3_api contains null pointer for ", "expired", " function" @@ -5511,10 +5400,8 @@ pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int } pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).finalize.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).finalize.expect(stringify!( "sqlite3_api contains null pointer for ", "finalize", " function" @@ -5522,10 +5409,8 @@ pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_in } pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).free.expect(stringify!( "sqlite3_api contains null pointer for ", "free", " function" @@ -5533,10 +5418,8 @@ pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { } pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free_table.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).free_table.expect(stringify!( "sqlite3_api contains null pointer for ", "free_table", " function" @@ -5544,10 +5427,8 @@ pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { } pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_autocommit.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).get_autocommit.expect(stringify!( "sqlite3_api contains null pointer for ", "get_autocommit", " function" @@ -5558,10 +5439,8 @@ pub unsafe fn sqlite3_get_auxdata( arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_auxdata.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).get_auxdata.expect(stringify!( "sqlite3_api contains null pointer for ", "get_auxdata", " function" @@ -5576,10 +5455,8 @@ pub unsafe fn sqlite3_get_table( arg5: *mut ::std::os::raw::c_int, arg6: *mut *mut ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_table.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).get_table.expect(stringify!( "sqlite3_api contains null pointer for ", "get_table", " function" @@ -5587,10 +5464,8 @@ pub unsafe fn sqlite3_get_table( } pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).global_recover.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).global_recover.expect(stringify!( "sqlite3_api contains null pointer for ", "global_recover", " function" @@ -5598,10 +5473,8 @@ pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { } pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).interruptx.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).interruptx.expect(stringify!( "sqlite3_api contains null pointer for ", "interruptx", " function" @@ -5609,10 +5482,8 @@ pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { } pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).last_insert_rowid.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).last_insert_rowid.expect(stringify!( "sqlite3_api contains null pointer for ", "last_insert_rowid", " function" @@ -5620,10 +5491,8 @@ pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { } pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).libversion.expect(stringify!( "sqlite3_api contains null pointer for ", "libversion", " function" @@ -5631,10 +5500,8 @@ pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { } pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion_number.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).libversion_number.expect(stringify!( "sqlite3_api contains null pointer for ", "libversion_number", " function" @@ -5642,10 +5509,8 @@ pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { } pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).malloc.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).malloc.expect(stringify!( "sqlite3_api contains null pointer for ", "malloc", " function" @@ -5653,10 +5518,8 @@ pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw } pub unsafe fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mprintf.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).mprintf.expect(stringify!( "sqlite3_api contains null pointer for ", "mprintf", " function" @@ -5667,10 +5530,8 @@ pub unsafe fn sqlite3_open( arg1: *const ::std::os::raw::c_char, arg2: *mut *mut sqlite3, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).open.expect(stringify!( "sqlite3_api contains null pointer for ", "open", " function" @@ -5681,10 +5542,8 @@ pub unsafe fn sqlite3_open16( arg1: *const ::std::os::raw::c_void, arg2: *mut *mut sqlite3, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).open16.expect(stringify!( "sqlite3_api contains null pointer for ", "open16", " function" @@ -5698,10 +5557,8 @@ pub unsafe fn sqlite3_prepare( arg4: *mut *mut sqlite3_stmt, arg5: *mut *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).prepare.expect(stringify!( "sqlite3_api contains null pointer for ", "prepare", " function" @@ -5715,10 +5572,8 @@ pub unsafe fn sqlite3_prepare16( arg4: *mut *mut sqlite3_stmt, arg5: *mut *const ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).prepare16.expect(stringify!( "sqlite3_api contains null pointer for ", "prepare16", " function" @@ -5736,10 +5591,8 @@ pub unsafe fn sqlite3_profile( >, arg3: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).profile.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).profile.expect(stringify!( "sqlite3_api contains null pointer for ", "profile", " function" @@ -5754,10 +5607,8 @@ pub unsafe fn sqlite3_progress_handler( >, arg4: *mut ::std::os::raw::c_void, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).progress_handler.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).progress_handler.expect(stringify!( "sqlite3_api contains null pointer for ", "progress_handler", " function" @@ -5768,10 +5619,8 @@ pub unsafe fn sqlite3_realloc( arg1: *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).realloc.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).realloc.expect(stringify!( "sqlite3_api contains null pointer for ", "realloc", " function" @@ -5779,10 +5628,8 @@ pub unsafe fn sqlite3_realloc( } pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).reset.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).reset.expect(stringify!( "sqlite3_api contains null pointer for ", "reset", " function" @@ -5795,10 +5642,8 @@ pub unsafe fn sqlite3_result_blob( arg3: ::std::os::raw::c_int, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_blob.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_blob.expect(stringify!( "sqlite3_api contains null pointer for ", "result_blob", " function" @@ -5806,10 +5651,8 @@ pub unsafe fn sqlite3_result_blob( } pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_double.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_double.expect(stringify!( "sqlite3_api contains null pointer for ", "result_double", " function" @@ -5821,10 +5664,8 @@ pub unsafe fn sqlite3_result_error( arg2: *const ::std::os::raw::c_char, arg3: ::std::os::raw::c_int, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_error.expect(stringify!( "sqlite3_api contains null pointer for ", "result_error", " function" @@ -5836,10 +5677,8 @@ pub unsafe fn sqlite3_result_error16( arg2: *const ::std::os::raw::c_void, arg3: ::std::os::raw::c_int, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_error16.expect(stringify!( "sqlite3_api contains null pointer for ", "result_error16", " function" @@ -5847,10 +5686,8 @@ pub unsafe fn sqlite3_result_error16( } pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_int.expect(stringify!( "sqlite3_api contains null pointer for ", "result_int", " function" @@ -5858,10 +5695,8 @@ pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::ra } pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int64.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_int64.expect(stringify!( "sqlite3_api contains null pointer for ", "result_int64", " function" @@ -5869,10 +5704,8 @@ pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int6 } pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_null.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_null.expect(stringify!( "sqlite3_api contains null pointer for ", "result_null", " function" @@ -5885,10 +5718,8 @@ pub unsafe fn sqlite3_result_text( arg3: ::std::os::raw::c_int, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_text.expect(stringify!( "sqlite3_api contains null pointer for ", "result_text", " function" @@ -5901,10 +5732,8 @@ pub unsafe fn sqlite3_result_text16( arg3: ::std::os::raw::c_int, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_text16.expect(stringify!( "sqlite3_api contains null pointer for ", "result_text16", " function" @@ -5917,10 +5746,8 @@ pub unsafe fn sqlite3_result_text16be( arg3: ::std::os::raw::c_int, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16be.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_text16be.expect(stringify!( "sqlite3_api contains null pointer for ", "result_text16be", " function" @@ -5933,10 +5760,8 @@ pub unsafe fn sqlite3_result_text16le( arg3: ::std::os::raw::c_int, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16le.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_text16le.expect(stringify!( "sqlite3_api contains null pointer for ", "result_text16le", " function" @@ -5944,10 +5769,8 @@ pub unsafe fn sqlite3_result_text16le( } pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_value.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_value.expect(stringify!( "sqlite3_api contains null pointer for ", "result_value", " function" @@ -5959,10 +5782,8 @@ pub unsafe fn sqlite3_rollback_hook( arg2: ::std::option::Option, arg3: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).rollback_hook.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).rollback_hook.expect(stringify!( "sqlite3_api contains null pointer for ", "rollback_hook", " function" @@ -5983,10 +5804,8 @@ pub unsafe fn sqlite3_set_authorizer( >, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_authorizer.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).set_authorizer.expect(stringify!( "sqlite3_api contains null pointer for ", "set_authorizer", " function" @@ -5999,10 +5818,8 @@ pub unsafe fn sqlite3_set_auxdata( arg3: *mut ::std::os::raw::c_void, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_auxdata.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).set_auxdata.expect(stringify!( "sqlite3_api contains null pointer for ", "set_auxdata", " function" @@ -6014,10 +5831,8 @@ pub unsafe fn sqlite3_snprintf( arg2: *mut ::std::os::raw::c_char, arg3: *const ::std::os::raw::c_char, ) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).snprintf.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).snprintf.expect(stringify!( "sqlite3_api contains null pointer for ", "snprintf", " function" @@ -6025,10 +5840,8 @@ pub unsafe fn sqlite3_snprintf( } pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).step.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).step.expect(stringify!( "sqlite3_api contains null pointer for ", "step", " function" @@ -6046,10 +5859,8 @@ pub unsafe fn sqlite3_table_column_metadata( arg8: *mut ::std::os::raw::c_int, arg9: *mut ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).table_column_metadata.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).table_column_metadata.expect(stringify!( "sqlite3_api contains null pointer for ", "table_column_metadata", " function" @@ -6057,10 +5868,8 @@ pub unsafe fn sqlite3_table_column_metadata( } pub unsafe fn sqlite3_thread_cleanup() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).thread_cleanup.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).thread_cleanup.expect(stringify!( "sqlite3_api contains null pointer for ", "thread_cleanup", " function" @@ -6068,10 +5877,8 @@ pub unsafe fn sqlite3_thread_cleanup() { } pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).total_changes.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).total_changes.expect(stringify!( "sqlite3_api contains null pointer for ", "total_changes", " function" @@ -6088,10 +5895,8 @@ pub unsafe fn sqlite3_trace( >, arg2: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).trace.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).trace.expect(stringify!( "sqlite3_api contains null pointer for ", "trace", " function" @@ -6102,10 +5907,8 @@ pub unsafe fn sqlite3_transfer_bindings( arg1: *mut sqlite3_stmt, arg2: *mut sqlite3_stmt, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).transfer_bindings.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).transfer_bindings.expect(stringify!( "sqlite3_api contains null pointer for ", "transfer_bindings", " function" @@ -6125,10 +5928,8 @@ pub unsafe fn sqlite3_update_hook( >, arg3: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).update_hook.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).update_hook.expect(stringify!( "sqlite3_api contains null pointer for ", "update_hook", " function" @@ -6136,10 +5937,8 @@ pub unsafe fn sqlite3_update_hook( } pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).user_data.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).user_data.expect(stringify!( "sqlite3_api contains null pointer for ", "user_data", " function" @@ -6147,10 +5946,8 @@ pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::r } pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_blob.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_blob.expect(stringify!( "sqlite3_api contains null pointer for ", "value_blob", " function" @@ -6158,10 +5955,8 @@ pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os:: } pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_bytes.expect(stringify!( "sqlite3_api contains null pointer for ", "value_bytes", " function" @@ -6169,10 +5964,8 @@ pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c } pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_bytes16.expect(stringify!( "sqlite3_api contains null pointer for ", "value_bytes16", " function" @@ -6180,10 +5973,8 @@ pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw: } pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_double.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_double.expect(stringify!( "sqlite3_api contains null pointer for ", "value_double", " function" @@ -6191,10 +5982,8 @@ pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { } pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_int.expect(stringify!( "sqlite3_api contains null pointer for ", "value_int", " function" @@ -6202,10 +5991,8 @@ pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_i } pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int64.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_int64.expect(stringify!( "sqlite3_api contains null pointer for ", "value_int64", " function" @@ -6213,10 +6000,8 @@ pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { } pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_numeric_type.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_numeric_type.expect(stringify!( "sqlite3_api contains null pointer for ", "value_numeric_type", " function" @@ -6224,10 +6009,8 @@ pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os: } pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_text.expect(stringify!( "sqlite3_api contains null pointer for ", "value_text", " function" @@ -6235,10 +6018,8 @@ pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os:: } pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_text16.expect(stringify!( "sqlite3_api contains null pointer for ", "value_text16", " function" @@ -6246,10 +6027,8 @@ pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os } pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16be.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_text16be.expect(stringify!( "sqlite3_api contains null pointer for ", "value_text16be", " function" @@ -6257,10 +6036,8 @@ pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std:: } pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16le.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_text16le.expect(stringify!( "sqlite3_api contains null pointer for ", "value_text16le", " function" @@ -6268,10 +6045,8 @@ pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std:: } pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_type.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_type.expect(stringify!( "sqlite3_api contains null pointer for ", "value_type", " function" @@ -6282,10 +6057,8 @@ pub unsafe fn sqlite3_vmprintf( arg1: *const ::std::os::raw::c_char, arg2: *mut __va_list_tag, ) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vmprintf.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).vmprintf.expect(stringify!( "sqlite3_api contains null pointer for ", "vmprintf", " function" @@ -6297,10 +6070,19 @@ pub unsafe fn sqlite3_overload_function( zFuncName: *const ::std::os::raw::c_char, nArg: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3003013i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_overload_function, + " function" + ), + sqlite3_version_number, 3003013i32 + ); } - ((*sqlite3_api).overload_function.expect(stringify!( + ((*p_api).overload_function.expect(stringify!( "sqlite3_api contains null pointer for ", "overload_function", " function" @@ -6314,10 +6096,19 @@ pub unsafe fn sqlite3_prepare_v2( arg4: *mut *mut sqlite3_stmt, arg5: *mut *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3003013i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_prepare_v2, + " function" + ), + sqlite3_version_number, 3003013i32 + ); } - ((*sqlite3_api).prepare_v2.expect(stringify!( + ((*p_api).prepare_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "prepare_v2", " function" @@ -6331,10 +6122,19 @@ pub unsafe fn sqlite3_prepare16_v2( arg4: *mut *mut sqlite3_stmt, arg5: *mut *const ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3003013i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_prepare16_v2, + " function" + ), + sqlite3_version_number, 3003013i32 + ); } - ((*sqlite3_api).prepare16_v2.expect(stringify!( + ((*p_api).prepare16_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "prepare16_v2", " function" @@ -6342,10 +6142,19 @@ pub unsafe fn sqlite3_prepare16_v2( } pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3003013i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_clear_bindings, + " function" + ), + sqlite3_version_number, 3003013i32 + ); } - ((*sqlite3_api).clear_bindings.expect(stringify!( + ((*p_api).clear_bindings.expect(stringify!( "sqlite3_api contains null pointer for ", "clear_bindings", " function" @@ -6359,10 +6168,19 @@ pub unsafe fn sqlite3_create_module_v2( arg4: *mut ::std::os::raw::c_void, xDestroy: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3004001i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_create_module_v2, + " function" + ), + sqlite3_version_number, 3004001i32 + ); } - ((*sqlite3_api).create_module_v2.expect(stringify!( + ((*p_api).create_module_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "create_module_v2", " function" @@ -6374,10 +6192,19 @@ pub unsafe fn sqlite3_bind_zeroblob( arg2: ::std::os::raw::c_int, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_bind_zeroblob, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).bind_zeroblob.expect(stringify!( + ((*p_api).bind_zeroblob.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_zeroblob", " function" @@ -6385,10 +6212,19 @@ pub unsafe fn sqlite3_bind_zeroblob( } pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_bytes, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_bytes.expect(stringify!( + ((*p_api).blob_bytes.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_bytes", " function" @@ -6396,10 +6232,19 @@ pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_i } pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_close, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_close.expect(stringify!( + ((*p_api).blob_close.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_close", " function" @@ -6415,10 +6260,19 @@ pub unsafe fn sqlite3_blob_open( arg6: ::std::os::raw::c_int, arg7: *mut *mut sqlite3_blob, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_open, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_open.expect(stringify!( + ((*p_api).blob_open.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_open", " function" @@ -6431,10 +6285,19 @@ pub unsafe fn sqlite3_blob_read( arg3: ::std::os::raw::c_int, arg4: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_read, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_read.expect(stringify!( + ((*p_api).blob_read.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_read", " function" @@ -6447,10 +6310,19 @@ pub unsafe fn sqlite3_blob_write( arg3: ::std::os::raw::c_int, arg4: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_write, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_write.expect(stringify!( + ((*p_api).blob_write.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_write", " function" @@ -6473,10 +6345,19 @@ pub unsafe fn sqlite3_create_collation_v2( >, arg6: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_create_collation_v2, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).create_collation_v2.expect(stringify!( + ((*p_api).create_collation_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "create_collation_v2", " function" @@ -6489,10 +6370,19 @@ pub unsafe fn sqlite3_file_control( arg3: ::std::os::raw::c_int, arg4: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_file_control, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).file_control.expect(stringify!( + ((*p_api).file_control.expect(stringify!( "sqlite3_api contains null pointer for ", "file_control", " function" @@ -6500,10 +6390,19 @@ pub unsafe fn sqlite3_file_control( } pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_memory_highwater, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).memory_highwater.expect(stringify!( + ((*p_api).memory_highwater.expect(stringify!( "sqlite3_api contains null pointer for ", "memory_highwater", " function" @@ -6511,10 +6410,19 @@ pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_i } pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_memory_used, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).memory_used.expect(stringify!( + ((*p_api).memory_used.expect(stringify!( "sqlite3_api contains null pointer for ", "memory_used", " function" @@ -6522,10 +6430,19 @@ pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { } pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_mutex_alloc, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).mutex_alloc.expect(stringify!( + ((*p_api).mutex_alloc.expect(stringify!( "sqlite3_api contains null pointer for ", "mutex_alloc", " function" @@ -6533,10 +6450,19 @@ pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_m } pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_mutex_enter, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).mutex_enter.expect(stringify!( + ((*p_api).mutex_enter.expect(stringify!( "sqlite3_api contains null pointer for ", "mutex_enter", " function" @@ -6544,10 +6470,19 @@ pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { } pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_mutex_free, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).mutex_free.expect(stringify!( + ((*p_api).mutex_free.expect(stringify!( "sqlite3_api contains null pointer for ", "mutex_free", " function" @@ -6555,10 +6490,19 @@ pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { } pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_mutex_leave, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).mutex_leave.expect(stringify!( + ((*p_api).mutex_leave.expect(stringify!( "sqlite3_api contains null pointer for ", "mutex_leave", " function" @@ -6566,10 +6510,19 @@ pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { } pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_mutex_try, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).mutex_try.expect(stringify!( + ((*p_api).mutex_try.expect(stringify!( "sqlite3_api contains null pointer for ", "mutex_try", " function" @@ -6582,10 +6535,19 @@ pub unsafe fn sqlite3_open_v2( arg3: ::std::os::raw::c_int, arg4: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_open_v2, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).open_v2.expect(stringify!( + ((*p_api).open_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "open_v2", " function" @@ -6593,10 +6555,19 @@ pub unsafe fn sqlite3_open_v2( } pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_release_memory, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).release_memory.expect(stringify!( + ((*p_api).release_memory.expect(stringify!( "sqlite3_api contains null pointer for ", "release_memory", " function" @@ -6604,10 +6575,19 @@ pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os:: } pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_result_error_nomem, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).result_error_nomem.expect(stringify!( + ((*p_api).result_error_nomem.expect(stringify!( "sqlite3_api contains null pointer for ", "result_error_nomem", " function" @@ -6615,10 +6595,19 @@ pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { } pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_result_error_toobig, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).result_error_toobig.expect(stringify!( + ((*p_api).result_error_toobig.expect(stringify!( "sqlite3_api contains null pointer for ", "result_error_toobig", " function" @@ -6626,10 +6615,19 @@ pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { } pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_sleep, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).sleep.expect(stringify!( + ((*p_api).sleep.expect(stringify!( "sqlite3_api contains null pointer for ", "sleep", " function" @@ -6637,10 +6635,19 @@ pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_in } pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_soft_heap_limit, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).soft_heap_limit.expect(stringify!( + ((*p_api).soft_heap_limit.expect(stringify!( "sqlite3_api contains null pointer for ", "soft_heap_limit", " function" @@ -6648,10 +6655,19 @@ pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { } pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_vfs_find, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).vfs_find.expect(stringify!( + ((*p_api).vfs_find.expect(stringify!( "sqlite3_api contains null pointer for ", "vfs_find", " function" @@ -6662,10 +6678,19 @@ pub unsafe fn sqlite3_vfs_register( arg1: *mut sqlite3_vfs, arg2: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_vfs_register, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).vfs_register.expect(stringify!( + ((*p_api).vfs_register.expect(stringify!( "sqlite3_api contains null pointer for ", "vfs_register", " function" @@ -6673,10 +6698,19 @@ pub unsafe fn sqlite3_vfs_register( } pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_vfs_unregister, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).vfs_unregister.expect(stringify!( + ((*p_api).vfs_unregister.expect(stringify!( "sqlite3_api contains null pointer for ", "vfs_unregister", " function" @@ -6684,10 +6718,19 @@ pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw:: } pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_xthreadsafe, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).xthreadsafe.expect(stringify!( + ((*p_api).xthreadsafe.expect(stringify!( "sqlite3_api contains null pointer for ", "xthreadsafe", " function" @@ -6695,10 +6738,19 @@ pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { } pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_result_zeroblob, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).result_zeroblob.expect(stringify!( + ((*p_api).result_zeroblob.expect(stringify!( "sqlite3_api contains null pointer for ", "result_zeroblob", " function" @@ -6706,10 +6758,19 @@ pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::o } pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_result_error_code, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).result_error_code.expect(stringify!( + ((*p_api).result_error_code.expect(stringify!( "sqlite3_api contains null pointer for ", "result_error_code", " function" @@ -6717,10 +6778,19 @@ pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std: } pub unsafe fn sqlite3_test_control(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_test_control, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).test_control.expect(stringify!( + ((*p_api).test_control.expect(stringify!( "sqlite3_api contains null pointer for ", "test_control", " function" @@ -6728,10 +6798,19 @@ pub unsafe fn sqlite3_test_control(arg1: ::std::os::raw::c_int) -> ::std::os::ra } pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_randomness, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).randomness.expect(stringify!( + ((*p_api).randomness.expect(stringify!( "sqlite3_api contains null pointer for ", "randomness", " function" @@ -6739,10 +6818,19 @@ pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std:: } pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_context_db_handle, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).context_db_handle.expect(stringify!( + ((*p_api).context_db_handle.expect(stringify!( "sqlite3_api contains null pointer for ", "context_db_handle", " function" @@ -6753,10 +6841,19 @@ pub unsafe fn sqlite3_extended_result_codes( arg1: *mut sqlite3, arg2: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_extended_result_codes, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).extended_result_codes.expect(stringify!( + ((*p_api).extended_result_codes.expect(stringify!( "sqlite3_api contains null pointer for ", "extended_result_codes", " function" @@ -6768,10 +6865,19 @@ pub unsafe fn sqlite3_limit( arg2: ::std::os::raw::c_int, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_limit, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).limit.expect(stringify!( + ((*p_api).limit.expect(stringify!( "sqlite3_api contains null pointer for ", "limit", " function" @@ -6779,10 +6885,19 @@ pub unsafe fn sqlite3_limit( } pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_next_stmt, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).next_stmt.expect(stringify!( + ((*p_api).next_stmt.expect(stringify!( "sqlite3_api contains null pointer for ", "next_stmt", " function" @@ -6790,10 +6905,19 @@ pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> } pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_sql, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).sql.expect(stringify!( + ((*p_api).sql.expect(stringify!( "sqlite3_api contains null pointer for ", "sql", " function" @@ -6806,10 +6930,19 @@ pub unsafe fn sqlite3_status( arg3: *mut ::std::os::raw::c_int, arg4: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_status, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).status.expect(stringify!( + ((*p_api).status.expect(stringify!( "sqlite3_api contains null pointer for ", "status", " function" diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs index 39ee0a41b..23ef550c0 100644 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.16-ext.rs @@ -1,9 +1,9 @@ -/* automatically generated by rust-bindgen 0.57.0 */ +/* automatically generated by rust-bindgen 0.59.2 */ pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.7.16\0"; +pub const SQLITE_VERSION: &[u8; 7usize] = b"3.7.16\0"; pub const SQLITE_VERSION_NUMBER: i32 = 3007016; -pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = +pub const SQLITE_SOURCE_ID: &[u8; 61usize] = b"2013-03-18 11:39:23 66d5f2b76750f3520eb7a495f6247206758f5b90\0"; pub const SQLITE_OK: i32 = 0; pub const SQLITE_ERROR: i32 = 1; @@ -5876,19 +5876,20 @@ fn bindgen_test_layout___va_list_tag() { ); } -// sqlite3_api is defined in lib.rs as either a static or an extern when compiled as a loadable_extension -use crate::sqlite3_api; +// The `loadable_extension_sqlite3_api` function is defined when compiled as a +// loadable_extension. It is used to safely access the static `SQLITE3_API` +// reference that is populated by a call to either`loadable_extension_init` +// or `loadable_extension_embedded_init` +use crate::loadable_extension_sqlite3_api; -// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from libsqlite3-sys/build.rs - not by rust-bindgen) pub unsafe fn sqlite3_aggregate_context( arg1: *mut sqlite3_context, nBytes: ::std::os::raw::c_int, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_context.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).aggregate_context.expect(stringify!( "sqlite3_api contains null pointer for ", "aggregate_context", " function" @@ -5896,10 +5897,8 @@ pub unsafe fn sqlite3_aggregate_context( } pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_count.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).aggregate_count.expect(stringify!( "sqlite3_api contains null pointer for ", "aggregate_count", " function" @@ -5913,10 +5912,8 @@ pub unsafe fn sqlite3_bind_blob( n: ::std::os::raw::c_int, arg4: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_blob.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_blob.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_blob", " function" @@ -5928,10 +5925,8 @@ pub unsafe fn sqlite3_bind_double( arg2: ::std::os::raw::c_int, arg3: f64, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_double.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_double.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_double", " function" @@ -5943,10 +5938,8 @@ pub unsafe fn sqlite3_bind_int( arg2: ::std::os::raw::c_int, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_int.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_int", " function" @@ -5958,10 +5951,8 @@ pub unsafe fn sqlite3_bind_int64( arg2: ::std::os::raw::c_int, arg3: sqlite_int64, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int64.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_int64.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_int64", " function" @@ -5972,10 +5963,8 @@ pub unsafe fn sqlite3_bind_null( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_null.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_null.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_null", " function" @@ -5983,10 +5972,8 @@ pub unsafe fn sqlite3_bind_null( } pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_count.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_parameter_count.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_parameter_count", " function" @@ -5997,10 +5984,8 @@ pub unsafe fn sqlite3_bind_parameter_index( arg1: *mut sqlite3_stmt, zName: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_index.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_parameter_index.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_parameter_index", " function" @@ -6011,10 +5996,8 @@ pub unsafe fn sqlite3_bind_parameter_name( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_name.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_parameter_name.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_parameter_name", " function" @@ -6028,10 +6011,8 @@ pub unsafe fn sqlite3_bind_text( n: ::std::os::raw::c_int, arg4: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_text.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_text", " function" @@ -6045,10 +6026,8 @@ pub unsafe fn sqlite3_bind_text16( arg4: ::std::os::raw::c_int, arg5: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_text16.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_text16", " function" @@ -6060,10 +6039,8 @@ pub unsafe fn sqlite3_bind_value( arg2: ::std::os::raw::c_int, arg3: *const sqlite3_value, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_value.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_value.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_value", " function" @@ -6080,10 +6057,8 @@ pub unsafe fn sqlite3_busy_handler( >, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_handler.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).busy_handler.expect(stringify!( "sqlite3_api contains null pointer for ", "busy_handler", " function" @@ -6094,10 +6069,8 @@ pub unsafe fn sqlite3_busy_timeout( arg1: *mut sqlite3, ms: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_timeout.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).busy_timeout.expect(stringify!( "sqlite3_api contains null pointer for ", "busy_timeout", " function" @@ -6105,10 +6078,8 @@ pub unsafe fn sqlite3_busy_timeout( } pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).changes.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).changes.expect(stringify!( "sqlite3_api contains null pointer for ", "changes", " function" @@ -6116,10 +6087,8 @@ pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { } pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).close.expect(stringify!( "sqlite3_api contains null pointer for ", "close", " function" @@ -6138,10 +6107,8 @@ pub unsafe fn sqlite3_collation_needed( ), >, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).collation_needed.expect(stringify!( "sqlite3_api contains null pointer for ", "collation_needed", " function" @@ -6160,10 +6127,8 @@ pub unsafe fn sqlite3_collation_needed16( ), >, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).collation_needed16.expect(stringify!( "sqlite3_api contains null pointer for ", "collation_needed16", " function" @@ -6174,10 +6139,8 @@ pub unsafe fn sqlite3_column_blob( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_blob.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_blob.expect(stringify!( "sqlite3_api contains null pointer for ", "column_blob", " function" @@ -6188,10 +6151,8 @@ pub unsafe fn sqlite3_column_bytes( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_bytes.expect(stringify!( "sqlite3_api contains null pointer for ", "column_bytes", " function" @@ -6202,10 +6163,8 @@ pub unsafe fn sqlite3_column_bytes16( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_bytes16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_bytes16", " function" @@ -6213,10 +6172,8 @@ pub unsafe fn sqlite3_column_bytes16( } pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_count.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_count.expect(stringify!( "sqlite3_api contains null pointer for ", "column_count", " function" @@ -6227,10 +6184,8 @@ pub unsafe fn sqlite3_column_database_name( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_database_name.expect(stringify!( "sqlite3_api contains null pointer for ", "column_database_name", " function" @@ -6241,10 +6196,8 @@ pub unsafe fn sqlite3_column_database_name16( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_database_name16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_database_name16", " function" @@ -6255,10 +6208,8 @@ pub unsafe fn sqlite3_column_decltype( arg1: *mut sqlite3_stmt, i: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_decltype.expect(stringify!( "sqlite3_api contains null pointer for ", "column_decltype", " function" @@ -6269,10 +6220,8 @@ pub unsafe fn sqlite3_column_decltype16( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_decltype16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_decltype16", " function" @@ -6280,10 +6229,8 @@ pub unsafe fn sqlite3_column_decltype16( } pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_double.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_double.expect(stringify!( "sqlite3_api contains null pointer for ", "column_double", " function" @@ -6294,10 +6241,8 @@ pub unsafe fn sqlite3_column_int( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_int.expect(stringify!( "sqlite3_api contains null pointer for ", "column_int", " function" @@ -6308,10 +6253,8 @@ pub unsafe fn sqlite3_column_int64( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int64.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_int64.expect(stringify!( "sqlite3_api contains null pointer for ", "column_int64", " function" @@ -6322,10 +6265,8 @@ pub unsafe fn sqlite3_column_name( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_name.expect(stringify!( "sqlite3_api contains null pointer for ", "column_name", " function" @@ -6336,10 +6277,8 @@ pub unsafe fn sqlite3_column_name16( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_name16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_name16", " function" @@ -6350,10 +6289,8 @@ pub unsafe fn sqlite3_column_origin_name( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_origin_name.expect(stringify!( "sqlite3_api contains null pointer for ", "column_origin_name", " function" @@ -6364,10 +6301,8 @@ pub unsafe fn sqlite3_column_origin_name16( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_origin_name16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_origin_name16", " function" @@ -6378,10 +6313,8 @@ pub unsafe fn sqlite3_column_table_name( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_table_name.expect(stringify!( "sqlite3_api contains null pointer for ", "column_table_name", " function" @@ -6392,10 +6325,8 @@ pub unsafe fn sqlite3_column_table_name16( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_table_name16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_table_name16", " function" @@ -6406,10 +6337,8 @@ pub unsafe fn sqlite3_column_text( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_text.expect(stringify!( "sqlite3_api contains null pointer for ", "column_text", " function" @@ -6420,10 +6349,8 @@ pub unsafe fn sqlite3_column_text16( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_text16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_text16", " function" @@ -6434,10 +6361,8 @@ pub unsafe fn sqlite3_column_type( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_type.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_type.expect(stringify!( "sqlite3_api contains null pointer for ", "column_type", " function" @@ -6448,10 +6373,8 @@ pub unsafe fn sqlite3_column_value( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_value.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_value.expect(stringify!( "sqlite3_api contains null pointer for ", "column_value", " function" @@ -6465,10 +6388,8 @@ pub unsafe fn sqlite3_commit_hook( >, arg3: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).commit_hook.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).commit_hook.expect(stringify!( "sqlite3_api contains null pointer for ", "commit_hook", " function" @@ -6476,10 +6397,8 @@ pub unsafe fn sqlite3_commit_hook( } pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).complete.expect(stringify!( "sqlite3_api contains null pointer for ", "complete", " function" @@ -6487,10 +6406,8 @@ pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os: } pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).complete16.expect(stringify!( "sqlite3_api contains null pointer for ", "complete16", " function" @@ -6512,10 +6429,8 @@ pub unsafe fn sqlite3_create_collation( ) -> ::std::os::raw::c_int, >, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).create_collation.expect(stringify!( "sqlite3_api contains null pointer for ", "create_collation", " function" @@ -6537,10 +6452,8 @@ pub unsafe fn sqlite3_create_collation16( ) -> ::std::os::raw::c_int, >, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).create_collation16.expect(stringify!( "sqlite3_api contains null pointer for ", "create_collation16", " function" @@ -6569,10 +6482,8 @@ pub unsafe fn sqlite3_create_function( >, xFinal: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).create_function.expect(stringify!( "sqlite3_api contains null pointer for ", "create_function", " function" @@ -6601,10 +6512,8 @@ pub unsafe fn sqlite3_create_function16( >, xFinal: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).create_function16.expect(stringify!( "sqlite3_api contains null pointer for ", "create_function16", " function" @@ -6617,10 +6526,8 @@ pub unsafe fn sqlite3_create_module( arg3: *const sqlite3_module, arg4: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).create_module.expect(stringify!( "sqlite3_api contains null pointer for ", "create_module", " function" @@ -6628,10 +6535,8 @@ pub unsafe fn sqlite3_create_module( } pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).data_count.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).data_count.expect(stringify!( "sqlite3_api contains null pointer for ", "data_count", " function" @@ -6639,10 +6544,8 @@ pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_ } pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_handle.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).db_handle.expect(stringify!( "sqlite3_api contains null pointer for ", "db_handle", " function" @@ -6653,10 +6556,8 @@ pub unsafe fn sqlite3_declare_vtab( arg1: *mut sqlite3, arg2: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).declare_vtab.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).declare_vtab.expect(stringify!( "sqlite3_api contains null pointer for ", "declare_vtab", " function" @@ -6664,10 +6565,8 @@ pub unsafe fn sqlite3_declare_vtab( } pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).enable_shared_cache.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).enable_shared_cache.expect(stringify!( "sqlite3_api contains null pointer for ", "enable_shared_cache", " function" @@ -6675,10 +6574,8 @@ pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std: } pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errcode.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).errcode.expect(stringify!( "sqlite3_api contains null pointer for ", "errcode", " function" @@ -6686,10 +6583,8 @@ pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { } pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).errmsg.expect(stringify!( "sqlite3_api contains null pointer for ", "errmsg", " function" @@ -6697,10 +6592,8 @@ pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_cha } pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).errmsg16.expect(stringify!( "sqlite3_api contains null pointer for ", "errmsg16", " function" @@ -6714,10 +6607,8 @@ pub unsafe fn sqlite3_exec( arg4: *mut ::std::os::raw::c_void, arg5: *mut *mut ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).exec.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).exec.expect(stringify!( "sqlite3_api contains null pointer for ", "exec", " function" @@ -6725,10 +6616,8 @@ pub unsafe fn sqlite3_exec( } pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).expired.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).expired.expect(stringify!( "sqlite3_api contains null pointer for ", "expired", " function" @@ -6736,10 +6625,8 @@ pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int } pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).finalize.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).finalize.expect(stringify!( "sqlite3_api contains null pointer for ", "finalize", " function" @@ -6747,10 +6634,8 @@ pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_in } pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).free.expect(stringify!( "sqlite3_api contains null pointer for ", "free", " function" @@ -6758,10 +6643,8 @@ pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { } pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free_table.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).free_table.expect(stringify!( "sqlite3_api contains null pointer for ", "free_table", " function" @@ -6769,10 +6652,8 @@ pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { } pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_autocommit.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).get_autocommit.expect(stringify!( "sqlite3_api contains null pointer for ", "get_autocommit", " function" @@ -6783,10 +6664,8 @@ pub unsafe fn sqlite3_get_auxdata( arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_auxdata.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).get_auxdata.expect(stringify!( "sqlite3_api contains null pointer for ", "get_auxdata", " function" @@ -6801,10 +6680,8 @@ pub unsafe fn sqlite3_get_table( arg5: *mut ::std::os::raw::c_int, arg6: *mut *mut ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_table.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).get_table.expect(stringify!( "sqlite3_api contains null pointer for ", "get_table", " function" @@ -6812,10 +6689,8 @@ pub unsafe fn sqlite3_get_table( } pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).global_recover.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).global_recover.expect(stringify!( "sqlite3_api contains null pointer for ", "global_recover", " function" @@ -6823,10 +6698,8 @@ pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { } pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).interruptx.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).interruptx.expect(stringify!( "sqlite3_api contains null pointer for ", "interruptx", " function" @@ -6834,10 +6707,8 @@ pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { } pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).last_insert_rowid.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).last_insert_rowid.expect(stringify!( "sqlite3_api contains null pointer for ", "last_insert_rowid", " function" @@ -6845,10 +6716,8 @@ pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { } pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).libversion.expect(stringify!( "sqlite3_api contains null pointer for ", "libversion", " function" @@ -6856,10 +6725,8 @@ pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { } pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion_number.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).libversion_number.expect(stringify!( "sqlite3_api contains null pointer for ", "libversion_number", " function" @@ -6867,10 +6734,8 @@ pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { } pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).malloc.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).malloc.expect(stringify!( "sqlite3_api contains null pointer for ", "malloc", " function" @@ -6878,10 +6743,8 @@ pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw } pub unsafe fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mprintf.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).mprintf.expect(stringify!( "sqlite3_api contains null pointer for ", "mprintf", " function" @@ -6892,10 +6755,8 @@ pub unsafe fn sqlite3_open( arg1: *const ::std::os::raw::c_char, arg2: *mut *mut sqlite3, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).open.expect(stringify!( "sqlite3_api contains null pointer for ", "open", " function" @@ -6906,10 +6767,8 @@ pub unsafe fn sqlite3_open16( arg1: *const ::std::os::raw::c_void, arg2: *mut *mut sqlite3, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).open16.expect(stringify!( "sqlite3_api contains null pointer for ", "open16", " function" @@ -6923,10 +6782,8 @@ pub unsafe fn sqlite3_prepare( arg4: *mut *mut sqlite3_stmt, arg5: *mut *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).prepare.expect(stringify!( "sqlite3_api contains null pointer for ", "prepare", " function" @@ -6940,10 +6797,8 @@ pub unsafe fn sqlite3_prepare16( arg4: *mut *mut sqlite3_stmt, arg5: *mut *const ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).prepare16.expect(stringify!( "sqlite3_api contains null pointer for ", "prepare16", " function" @@ -6961,10 +6816,8 @@ pub unsafe fn sqlite3_profile( >, arg3: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).profile.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).profile.expect(stringify!( "sqlite3_api contains null pointer for ", "profile", " function" @@ -6979,10 +6832,8 @@ pub unsafe fn sqlite3_progress_handler( >, arg4: *mut ::std::os::raw::c_void, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).progress_handler.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).progress_handler.expect(stringify!( "sqlite3_api contains null pointer for ", "progress_handler", " function" @@ -6993,10 +6844,8 @@ pub unsafe fn sqlite3_realloc( arg1: *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).realloc.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).realloc.expect(stringify!( "sqlite3_api contains null pointer for ", "realloc", " function" @@ -7004,10 +6853,8 @@ pub unsafe fn sqlite3_realloc( } pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).reset.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).reset.expect(stringify!( "sqlite3_api contains null pointer for ", "reset", " function" @@ -7020,10 +6867,8 @@ pub unsafe fn sqlite3_result_blob( arg3: ::std::os::raw::c_int, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_blob.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_blob.expect(stringify!( "sqlite3_api contains null pointer for ", "result_blob", " function" @@ -7031,10 +6876,8 @@ pub unsafe fn sqlite3_result_blob( } pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_double.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_double.expect(stringify!( "sqlite3_api contains null pointer for ", "result_double", " function" @@ -7046,10 +6889,8 @@ pub unsafe fn sqlite3_result_error( arg2: *const ::std::os::raw::c_char, arg3: ::std::os::raw::c_int, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_error.expect(stringify!( "sqlite3_api contains null pointer for ", "result_error", " function" @@ -7061,10 +6902,8 @@ pub unsafe fn sqlite3_result_error16( arg2: *const ::std::os::raw::c_void, arg3: ::std::os::raw::c_int, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_error16.expect(stringify!( "sqlite3_api contains null pointer for ", "result_error16", " function" @@ -7072,10 +6911,8 @@ pub unsafe fn sqlite3_result_error16( } pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_int.expect(stringify!( "sqlite3_api contains null pointer for ", "result_int", " function" @@ -7083,10 +6920,8 @@ pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::ra } pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int64.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_int64.expect(stringify!( "sqlite3_api contains null pointer for ", "result_int64", " function" @@ -7094,10 +6929,8 @@ pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int6 } pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_null.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_null.expect(stringify!( "sqlite3_api contains null pointer for ", "result_null", " function" @@ -7110,10 +6943,8 @@ pub unsafe fn sqlite3_result_text( arg3: ::std::os::raw::c_int, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_text.expect(stringify!( "sqlite3_api contains null pointer for ", "result_text", " function" @@ -7126,10 +6957,8 @@ pub unsafe fn sqlite3_result_text16( arg3: ::std::os::raw::c_int, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_text16.expect(stringify!( "sqlite3_api contains null pointer for ", "result_text16", " function" @@ -7142,10 +6971,8 @@ pub unsafe fn sqlite3_result_text16be( arg3: ::std::os::raw::c_int, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16be.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_text16be.expect(stringify!( "sqlite3_api contains null pointer for ", "result_text16be", " function" @@ -7158,10 +6985,8 @@ pub unsafe fn sqlite3_result_text16le( arg3: ::std::os::raw::c_int, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16le.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_text16le.expect(stringify!( "sqlite3_api contains null pointer for ", "result_text16le", " function" @@ -7169,10 +6994,8 @@ pub unsafe fn sqlite3_result_text16le( } pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_value.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_value.expect(stringify!( "sqlite3_api contains null pointer for ", "result_value", " function" @@ -7184,10 +7007,8 @@ pub unsafe fn sqlite3_rollback_hook( arg2: ::std::option::Option, arg3: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).rollback_hook.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).rollback_hook.expect(stringify!( "sqlite3_api contains null pointer for ", "rollback_hook", " function" @@ -7208,10 +7029,8 @@ pub unsafe fn sqlite3_set_authorizer( >, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_authorizer.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).set_authorizer.expect(stringify!( "sqlite3_api contains null pointer for ", "set_authorizer", " function" @@ -7224,10 +7043,8 @@ pub unsafe fn sqlite3_set_auxdata( arg3: *mut ::std::os::raw::c_void, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_auxdata.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).set_auxdata.expect(stringify!( "sqlite3_api contains null pointer for ", "set_auxdata", " function" @@ -7239,10 +7056,8 @@ pub unsafe fn sqlite3_snprintf( arg2: *mut ::std::os::raw::c_char, arg3: *const ::std::os::raw::c_char, ) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).snprintf.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).snprintf.expect(stringify!( "sqlite3_api contains null pointer for ", "snprintf", " function" @@ -7250,10 +7065,8 @@ pub unsafe fn sqlite3_snprintf( } pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).step.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).step.expect(stringify!( "sqlite3_api contains null pointer for ", "step", " function" @@ -7271,10 +7084,8 @@ pub unsafe fn sqlite3_table_column_metadata( arg8: *mut ::std::os::raw::c_int, arg9: *mut ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).table_column_metadata.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).table_column_metadata.expect(stringify!( "sqlite3_api contains null pointer for ", "table_column_metadata", " function" @@ -7282,10 +7093,8 @@ pub unsafe fn sqlite3_table_column_metadata( } pub unsafe fn sqlite3_thread_cleanup() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).thread_cleanup.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).thread_cleanup.expect(stringify!( "sqlite3_api contains null pointer for ", "thread_cleanup", " function" @@ -7293,10 +7102,8 @@ pub unsafe fn sqlite3_thread_cleanup() { } pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).total_changes.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).total_changes.expect(stringify!( "sqlite3_api contains null pointer for ", "total_changes", " function" @@ -7313,10 +7120,8 @@ pub unsafe fn sqlite3_trace( >, arg2: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).trace.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).trace.expect(stringify!( "sqlite3_api contains null pointer for ", "trace", " function" @@ -7327,10 +7132,8 @@ pub unsafe fn sqlite3_transfer_bindings( arg1: *mut sqlite3_stmt, arg2: *mut sqlite3_stmt, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).transfer_bindings.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).transfer_bindings.expect(stringify!( "sqlite3_api contains null pointer for ", "transfer_bindings", " function" @@ -7350,10 +7153,8 @@ pub unsafe fn sqlite3_update_hook( >, arg3: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).update_hook.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).update_hook.expect(stringify!( "sqlite3_api contains null pointer for ", "update_hook", " function" @@ -7361,10 +7162,8 @@ pub unsafe fn sqlite3_update_hook( } pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).user_data.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).user_data.expect(stringify!( "sqlite3_api contains null pointer for ", "user_data", " function" @@ -7372,10 +7171,8 @@ pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::r } pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_blob.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_blob.expect(stringify!( "sqlite3_api contains null pointer for ", "value_blob", " function" @@ -7383,10 +7180,8 @@ pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os:: } pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_bytes.expect(stringify!( "sqlite3_api contains null pointer for ", "value_bytes", " function" @@ -7394,10 +7189,8 @@ pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c } pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_bytes16.expect(stringify!( "sqlite3_api contains null pointer for ", "value_bytes16", " function" @@ -7405,10 +7198,8 @@ pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw: } pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_double.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_double.expect(stringify!( "sqlite3_api contains null pointer for ", "value_double", " function" @@ -7416,10 +7207,8 @@ pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { } pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_int.expect(stringify!( "sqlite3_api contains null pointer for ", "value_int", " function" @@ -7427,10 +7216,8 @@ pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_i } pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int64.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_int64.expect(stringify!( "sqlite3_api contains null pointer for ", "value_int64", " function" @@ -7438,10 +7225,8 @@ pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { } pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_numeric_type.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_numeric_type.expect(stringify!( "sqlite3_api contains null pointer for ", "value_numeric_type", " function" @@ -7449,10 +7234,8 @@ pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os: } pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_text.expect(stringify!( "sqlite3_api contains null pointer for ", "value_text", " function" @@ -7460,10 +7243,8 @@ pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os:: } pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_text16.expect(stringify!( "sqlite3_api contains null pointer for ", "value_text16", " function" @@ -7471,10 +7252,8 @@ pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os } pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16be.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_text16be.expect(stringify!( "sqlite3_api contains null pointer for ", "value_text16be", " function" @@ -7482,10 +7261,8 @@ pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std:: } pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16le.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_text16le.expect(stringify!( "sqlite3_api contains null pointer for ", "value_text16le", " function" @@ -7493,10 +7270,8 @@ pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std:: } pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_type.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_type.expect(stringify!( "sqlite3_api contains null pointer for ", "value_type", " function" @@ -7507,10 +7282,8 @@ pub unsafe fn sqlite3_vmprintf( arg1: *const ::std::os::raw::c_char, arg2: *mut __va_list_tag, ) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vmprintf.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).vmprintf.expect(stringify!( "sqlite3_api contains null pointer for ", "vmprintf", " function" @@ -7522,10 +7295,19 @@ pub unsafe fn sqlite3_overload_function( zFuncName: *const ::std::os::raw::c_char, nArg: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3003013i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_overload_function, + " function" + ), + sqlite3_version_number, 3003013i32 + ); } - ((*sqlite3_api).overload_function.expect(stringify!( + ((*p_api).overload_function.expect(stringify!( "sqlite3_api contains null pointer for ", "overload_function", " function" @@ -7539,10 +7321,19 @@ pub unsafe fn sqlite3_prepare_v2( arg4: *mut *mut sqlite3_stmt, arg5: *mut *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3003013i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_prepare_v2, + " function" + ), + sqlite3_version_number, 3003013i32 + ); } - ((*sqlite3_api).prepare_v2.expect(stringify!( + ((*p_api).prepare_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "prepare_v2", " function" @@ -7556,10 +7347,19 @@ pub unsafe fn sqlite3_prepare16_v2( arg4: *mut *mut sqlite3_stmt, arg5: *mut *const ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3003013i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_prepare16_v2, + " function" + ), + sqlite3_version_number, 3003013i32 + ); } - ((*sqlite3_api).prepare16_v2.expect(stringify!( + ((*p_api).prepare16_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "prepare16_v2", " function" @@ -7567,10 +7367,19 @@ pub unsafe fn sqlite3_prepare16_v2( } pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3003013i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_clear_bindings, + " function" + ), + sqlite3_version_number, 3003013i32 + ); } - ((*sqlite3_api).clear_bindings.expect(stringify!( + ((*p_api).clear_bindings.expect(stringify!( "sqlite3_api contains null pointer for ", "clear_bindings", " function" @@ -7584,10 +7393,19 @@ pub unsafe fn sqlite3_create_module_v2( arg4: *mut ::std::os::raw::c_void, xDestroy: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3004001i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_create_module_v2, + " function" + ), + sqlite3_version_number, 3004001i32 + ); } - ((*sqlite3_api).create_module_v2.expect(stringify!( + ((*p_api).create_module_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "create_module_v2", " function" @@ -7599,10 +7417,19 @@ pub unsafe fn sqlite3_bind_zeroblob( arg2: ::std::os::raw::c_int, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_bind_zeroblob, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).bind_zeroblob.expect(stringify!( + ((*p_api).bind_zeroblob.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_zeroblob", " function" @@ -7610,10 +7437,19 @@ pub unsafe fn sqlite3_bind_zeroblob( } pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_bytes, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_bytes.expect(stringify!( + ((*p_api).blob_bytes.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_bytes", " function" @@ -7621,10 +7457,19 @@ pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_i } pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_close, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_close.expect(stringify!( + ((*p_api).blob_close.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_close", " function" @@ -7640,10 +7485,19 @@ pub unsafe fn sqlite3_blob_open( arg6: ::std::os::raw::c_int, arg7: *mut *mut sqlite3_blob, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_open, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_open.expect(stringify!( + ((*p_api).blob_open.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_open", " function" @@ -7656,10 +7510,19 @@ pub unsafe fn sqlite3_blob_read( arg3: ::std::os::raw::c_int, arg4: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_read, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_read.expect(stringify!( + ((*p_api).blob_read.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_read", " function" @@ -7672,10 +7535,19 @@ pub unsafe fn sqlite3_blob_write( arg3: ::std::os::raw::c_int, arg4: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_write, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_write.expect(stringify!( + ((*p_api).blob_write.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_write", " function" @@ -7698,10 +7570,19 @@ pub unsafe fn sqlite3_create_collation_v2( >, arg6: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_create_collation_v2, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).create_collation_v2.expect(stringify!( + ((*p_api).create_collation_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "create_collation_v2", " function" @@ -7714,10 +7595,19 @@ pub unsafe fn sqlite3_file_control( arg3: ::std::os::raw::c_int, arg4: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_file_control, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).file_control.expect(stringify!( + ((*p_api).file_control.expect(stringify!( "sqlite3_api contains null pointer for ", "file_control", " function" @@ -7725,10 +7615,19 @@ pub unsafe fn sqlite3_file_control( } pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_memory_highwater, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).memory_highwater.expect(stringify!( + ((*p_api).memory_highwater.expect(stringify!( "sqlite3_api contains null pointer for ", "memory_highwater", " function" @@ -7736,10 +7635,19 @@ pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_i } pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_memory_used, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).memory_used.expect(stringify!( + ((*p_api).memory_used.expect(stringify!( "sqlite3_api contains null pointer for ", "memory_used", " function" @@ -7747,10 +7655,19 @@ pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { } pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_mutex_alloc, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).mutex_alloc.expect(stringify!( + ((*p_api).mutex_alloc.expect(stringify!( "sqlite3_api contains null pointer for ", "mutex_alloc", " function" @@ -7758,10 +7675,19 @@ pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_m } pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_mutex_enter, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).mutex_enter.expect(stringify!( + ((*p_api).mutex_enter.expect(stringify!( "sqlite3_api contains null pointer for ", "mutex_enter", " function" @@ -7769,10 +7695,19 @@ pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { } pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_mutex_free, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).mutex_free.expect(stringify!( + ((*p_api).mutex_free.expect(stringify!( "sqlite3_api contains null pointer for ", "mutex_free", " function" @@ -7780,10 +7715,19 @@ pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { } pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_mutex_leave, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).mutex_leave.expect(stringify!( + ((*p_api).mutex_leave.expect(stringify!( "sqlite3_api contains null pointer for ", "mutex_leave", " function" @@ -7791,10 +7735,19 @@ pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { } pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_mutex_try, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).mutex_try.expect(stringify!( + ((*p_api).mutex_try.expect(stringify!( "sqlite3_api contains null pointer for ", "mutex_try", " function" @@ -7807,10 +7760,19 @@ pub unsafe fn sqlite3_open_v2( arg3: ::std::os::raw::c_int, arg4: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_open_v2, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).open_v2.expect(stringify!( + ((*p_api).open_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "open_v2", " function" @@ -7818,10 +7780,19 @@ pub unsafe fn sqlite3_open_v2( } pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_release_memory, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).release_memory.expect(stringify!( + ((*p_api).release_memory.expect(stringify!( "sqlite3_api contains null pointer for ", "release_memory", " function" @@ -7829,10 +7800,19 @@ pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os:: } pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_result_error_nomem, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).result_error_nomem.expect(stringify!( + ((*p_api).result_error_nomem.expect(stringify!( "sqlite3_api contains null pointer for ", "result_error_nomem", " function" @@ -7840,10 +7820,19 @@ pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { } pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_result_error_toobig, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).result_error_toobig.expect(stringify!( + ((*p_api).result_error_toobig.expect(stringify!( "sqlite3_api contains null pointer for ", "result_error_toobig", " function" @@ -7851,10 +7840,19 @@ pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { } pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_sleep, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).sleep.expect(stringify!( + ((*p_api).sleep.expect(stringify!( "sqlite3_api contains null pointer for ", "sleep", " function" @@ -7862,10 +7860,19 @@ pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_in } pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_soft_heap_limit, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).soft_heap_limit.expect(stringify!( + ((*p_api).soft_heap_limit.expect(stringify!( "sqlite3_api contains null pointer for ", "soft_heap_limit", " function" @@ -7873,10 +7880,19 @@ pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { } pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_vfs_find, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).vfs_find.expect(stringify!( + ((*p_api).vfs_find.expect(stringify!( "sqlite3_api contains null pointer for ", "vfs_find", " function" @@ -7887,10 +7903,19 @@ pub unsafe fn sqlite3_vfs_register( arg1: *mut sqlite3_vfs, arg2: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_vfs_register, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).vfs_register.expect(stringify!( + ((*p_api).vfs_register.expect(stringify!( "sqlite3_api contains null pointer for ", "vfs_register", " function" @@ -7898,10 +7923,19 @@ pub unsafe fn sqlite3_vfs_register( } pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_vfs_unregister, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).vfs_unregister.expect(stringify!( + ((*p_api).vfs_unregister.expect(stringify!( "sqlite3_api contains null pointer for ", "vfs_unregister", " function" @@ -7909,10 +7943,19 @@ pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw:: } pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_xthreadsafe, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).xthreadsafe.expect(stringify!( + ((*p_api).xthreadsafe.expect(stringify!( "sqlite3_api contains null pointer for ", "xthreadsafe", " function" @@ -7920,10 +7963,19 @@ pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { } pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_result_zeroblob, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).result_zeroblob.expect(stringify!( + ((*p_api).result_zeroblob.expect(stringify!( "sqlite3_api contains null pointer for ", "result_zeroblob", " function" @@ -7931,10 +7983,19 @@ pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::o } pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_result_error_code, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).result_error_code.expect(stringify!( + ((*p_api).result_error_code.expect(stringify!( "sqlite3_api contains null pointer for ", "result_error_code", " function" @@ -7942,10 +8003,19 @@ pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std: } pub unsafe fn sqlite3_test_control(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_test_control, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).test_control.expect(stringify!( + ((*p_api).test_control.expect(stringify!( "sqlite3_api contains null pointer for ", "test_control", " function" @@ -7953,10 +8023,19 @@ pub unsafe fn sqlite3_test_control(arg1: ::std::os::raw::c_int) -> ::std::os::ra } pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_randomness, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).randomness.expect(stringify!( + ((*p_api).randomness.expect(stringify!( "sqlite3_api contains null pointer for ", "randomness", " function" @@ -7964,10 +8043,19 @@ pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std:: } pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_context_db_handle, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).context_db_handle.expect(stringify!( + ((*p_api).context_db_handle.expect(stringify!( "sqlite3_api contains null pointer for ", "context_db_handle", " function" @@ -7978,10 +8066,19 @@ pub unsafe fn sqlite3_extended_result_codes( arg1: *mut sqlite3, arg2: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_extended_result_codes, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).extended_result_codes.expect(stringify!( + ((*p_api).extended_result_codes.expect(stringify!( "sqlite3_api contains null pointer for ", "extended_result_codes", " function" @@ -7993,10 +8090,19 @@ pub unsafe fn sqlite3_limit( arg2: ::std::os::raw::c_int, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_limit, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).limit.expect(stringify!( + ((*p_api).limit.expect(stringify!( "sqlite3_api contains null pointer for ", "limit", " function" @@ -8004,10 +8110,19 @@ pub unsafe fn sqlite3_limit( } pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_next_stmt, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).next_stmt.expect(stringify!( + ((*p_api).next_stmt.expect(stringify!( "sqlite3_api contains null pointer for ", "next_stmt", " function" @@ -8015,10 +8130,19 @@ pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> } pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_sql, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).sql.expect(stringify!( + ((*p_api).sql.expect(stringify!( "sqlite3_api contains null pointer for ", "sql", " function" @@ -8031,10 +8155,19 @@ pub unsafe fn sqlite3_status( arg3: *mut ::std::os::raw::c_int, arg4: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_status, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).status.expect(stringify!( + ((*p_api).status.expect(stringify!( "sqlite3_api contains null pointer for ", "status", " function" @@ -8042,10 +8175,19 @@ pub unsafe fn sqlite3_status( } pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_backup_finish, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).backup_finish.expect(stringify!( + ((*p_api).backup_finish.expect(stringify!( "sqlite3_api contains null pointer for ", "backup_finish", " function" @@ -8058,10 +8200,19 @@ pub unsafe fn sqlite3_backup_init( arg3: *mut sqlite3, arg4: *const ::std::os::raw::c_char, ) -> *mut sqlite3_backup { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_backup_init, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).backup_init.expect(stringify!( + ((*p_api).backup_init.expect(stringify!( "sqlite3_api contains null pointer for ", "backup_init", " function" @@ -8069,10 +8220,19 @@ pub unsafe fn sqlite3_backup_init( } pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_backup_pagecount, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).backup_pagecount.expect(stringify!( + ((*p_api).backup_pagecount.expect(stringify!( "sqlite3_api contains null pointer for ", "backup_pagecount", " function" @@ -8080,10 +8240,19 @@ pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os:: } pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_backup_remaining, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).backup_remaining.expect(stringify!( + ((*p_api).backup_remaining.expect(stringify!( "sqlite3_api contains null pointer for ", "backup_remaining", " function" @@ -8094,10 +8263,19 @@ pub unsafe fn sqlite3_backup_step( arg1: *mut sqlite3_backup, arg2: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_backup_step, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).backup_step.expect(stringify!( + ((*p_api).backup_step.expect(stringify!( "sqlite3_api contains null pointer for ", "backup_step", " function" @@ -8107,10 +8285,19 @@ pub unsafe fn sqlite3_backup_step( pub unsafe fn sqlite3_compileoption_get( arg1: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_compileoption_get, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).compileoption_get.expect(stringify!( + ((*p_api).compileoption_get.expect(stringify!( "sqlite3_api contains null pointer for ", "compileoption_get", " function" @@ -8120,10 +8307,19 @@ pub unsafe fn sqlite3_compileoption_get( pub unsafe fn sqlite3_compileoption_used( arg1: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_compileoption_used, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).compileoption_used.expect(stringify!( + ((*p_api).compileoption_used.expect(stringify!( "sqlite3_api contains null pointer for ", "compileoption_used", " function" @@ -8153,10 +8349,19 @@ pub unsafe fn sqlite3_create_function_v2( xFinal: ::std::option::Option, xDestroy: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_create_function_v2, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).create_function_v2.expect(stringify!( + ((*p_api).create_function_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "create_function_v2", " function" @@ -8167,10 +8372,19 @@ pub unsafe fn sqlite3_db_config( arg1: *mut sqlite3, arg2: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_db_config, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).db_config.expect(stringify!( + ((*p_api).db_config.expect(stringify!( "sqlite3_api contains null pointer for ", "db_config", " function" @@ -8182,10 +8396,19 @@ pub unsafe fn sqlite3_db_config_constchar( arg2: ::std::os::raw::c_int, vararg1: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_db_config_constchar, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).db_config.expect(stringify!( + ((*p_api).db_config.expect(stringify!( "sqlite3_api contains null pointer for ", "db_config", " function" @@ -8198,10 +8421,19 @@ pub unsafe fn sqlite3_db_config_int_mutint( vararg1: ::std::os::raw::c_int, vararg2: *mut ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_db_config_int_mutint, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).db_config.expect(stringify!( + ((*p_api).db_config.expect(stringify!( "sqlite3_api contains null pointer for ", "db_config", " function" @@ -8215,10 +8447,19 @@ pub unsafe fn sqlite3_db_config_void_int_mutint( vararg2: ::std::os::raw::c_int, vararg3: *mut ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_db_config_void_int_mutint, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).db_config.expect(stringify!( + ((*p_api).db_config.expect(stringify!( "sqlite3_api contains null pointer for ", "db_config", " function" @@ -8226,10 +8467,19 @@ pub unsafe fn sqlite3_db_config_void_int_mutint( } pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_db_mutex, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).db_mutex.expect(stringify!( + ((*p_api).db_mutex.expect(stringify!( "sqlite3_api contains null pointer for ", "db_mutex", " function" @@ -8243,10 +8493,19 @@ pub unsafe fn sqlite3_db_status( arg4: *mut ::std::os::raw::c_int, arg5: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_db_status, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).db_status.expect(stringify!( + ((*p_api).db_status.expect(stringify!( "sqlite3_api contains null pointer for ", "db_status", " function" @@ -8254,10 +8513,19 @@ pub unsafe fn sqlite3_db_status( } pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_extended_errcode, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).extended_errcode.expect(stringify!( + ((*p_api).extended_errcode.expect(stringify!( "sqlite3_api contains null pointer for ", "extended_errcode", " function" @@ -8265,10 +8533,19 @@ pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_ } pub unsafe fn sqlite3_log(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_log, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).log.expect(stringify!( + ((*p_api).log.expect(stringify!( "sqlite3_api contains null pointer for ", "log", " function" @@ -8276,10 +8553,19 @@ pub unsafe fn sqlite3_log(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::r } pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_soft_heap_limit64, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).soft_heap_limit64.expect(stringify!( + ((*p_api).soft_heap_limit64.expect(stringify!( "sqlite3_api contains null pointer for ", "soft_heap_limit64", " function" @@ -8287,10 +8573,19 @@ pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { } pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_sourceid, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).sourceid.expect(stringify!( + ((*p_api).sourceid.expect(stringify!( "sqlite3_api contains null pointer for ", "sourceid", " function" @@ -8302,10 +8597,19 @@ pub unsafe fn sqlite3_stmt_status( arg2: ::std::os::raw::c_int, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_stmt_status, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).stmt_status.expect(stringify!( + ((*p_api).stmt_status.expect(stringify!( "sqlite3_api contains null pointer for ", "stmt_status", " function" @@ -8317,10 +8621,19 @@ pub unsafe fn sqlite3_strnicmp( arg2: *const ::std::os::raw::c_char, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_strnicmp, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).strnicmp.expect(stringify!( + ((*p_api).strnicmp.expect(stringify!( "sqlite3_api contains null pointer for ", "strnicmp", " function" @@ -8334,10 +8647,19 @@ pub unsafe fn sqlite3_unlock_notify( >, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_unlock_notify, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).unlock_notify.expect(stringify!( + ((*p_api).unlock_notify.expect(stringify!( "sqlite3_api contains null pointer for ", "unlock_notify", " function" @@ -8348,10 +8670,19 @@ pub unsafe fn sqlite3_wal_autocheckpoint( arg1: *mut sqlite3, arg2: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_wal_autocheckpoint, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( + ((*p_api).wal_autocheckpoint.expect(stringify!( "sqlite3_api contains null pointer for ", "wal_autocheckpoint", " function" @@ -8362,10 +8693,19 @@ pub unsafe fn sqlite3_wal_checkpoint( arg1: *mut sqlite3, arg2: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_wal_checkpoint, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).wal_checkpoint.expect(stringify!( + ((*p_api).wal_checkpoint.expect(stringify!( "sqlite3_api contains null pointer for ", "wal_checkpoint", " function" @@ -8384,10 +8724,19 @@ pub unsafe fn sqlite3_wal_hook( >, arg3: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_wal_hook, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).wal_hook.expect(stringify!( + ((*p_api).wal_hook.expect(stringify!( "sqlite3_api contains null pointer for ", "wal_hook", " function" @@ -8398,10 +8747,19 @@ pub unsafe fn sqlite3_blob_reopen( arg1: *mut sqlite3_blob, arg2: sqlite3_int64, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_reopen, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_reopen.expect(stringify!( + ((*p_api).blob_reopen.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_reopen", " function" @@ -8412,10 +8770,19 @@ pub unsafe fn sqlite3_vtab_config( arg1: *mut sqlite3, op: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_vtab_config, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).vtab_config.expect(stringify!( + ((*p_api).vtab_config.expect(stringify!( "sqlite3_api contains null pointer for ", "vtab_config", " function" @@ -8427,10 +8794,19 @@ pub unsafe fn sqlite3_vtab_config_int( op: ::std::os::raw::c_int, vararg1: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_vtab_config_int, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).vtab_config.expect(stringify!( + ((*p_api).vtab_config.expect(stringify!( "sqlite3_api contains null pointer for ", "vtab_config", " function" @@ -8438,10 +8814,19 @@ pub unsafe fn sqlite3_vtab_config_int( } pub unsafe fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_vtab_on_conflict, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).vtab_on_conflict.expect(stringify!( + ((*p_api).vtab_on_conflict.expect(stringify!( "sqlite3_api contains null pointer for ", "vtab_on_conflict", " function" @@ -8449,10 +8834,19 @@ pub unsafe fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_ } pub unsafe fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3007016i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_close_v2, + " function" + ), + sqlite3_version_number, 3007016i32 + ); } - ((*sqlite3_api).close_v2.expect(stringify!( + ((*p_api).close_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "close_v2", " function" @@ -8463,10 +8857,19 @@ pub unsafe fn sqlite3_db_filename( arg1: *mut sqlite3, arg2: *const ::std::os::raw::c_char, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3007016i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_db_filename, + " function" + ), + sqlite3_version_number, 3007016i32 + ); } - ((*sqlite3_api).db_filename.expect(stringify!( + ((*p_api).db_filename.expect(stringify!( "sqlite3_api contains null pointer for ", "db_filename", " function" @@ -8477,10 +8880,19 @@ pub unsafe fn sqlite3_db_readonly( arg1: *mut sqlite3, arg2: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3007016i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_db_readonly, + " function" + ), + sqlite3_version_number, 3007016i32 + ); } - ((*sqlite3_api).db_readonly.expect(stringify!( + ((*p_api).db_readonly.expect(stringify!( "sqlite3_api contains null pointer for ", "db_readonly", " function" @@ -8488,10 +8900,19 @@ pub unsafe fn sqlite3_db_readonly( } pub unsafe fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3007016i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_db_release_memory, + " function" + ), + sqlite3_version_number, 3007016i32 + ); } - ((*sqlite3_api).db_release_memory.expect(stringify!( + ((*p_api).db_release_memory.expect(stringify!( "sqlite3_api contains null pointer for ", "db_release_memory", " function" @@ -8499,10 +8920,19 @@ pub unsafe fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c } pub unsafe fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3007016i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_errstr, + " function" + ), + sqlite3_version_number, 3007016i32 + ); } - ((*sqlite3_api).errstr.expect(stringify!( + ((*p_api).errstr.expect(stringify!( "sqlite3_api contains null pointer for ", "errstr", " function" @@ -8510,10 +8940,19 @@ pub unsafe fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::r } pub unsafe fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3007016i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_stmt_busy, + " function" + ), + sqlite3_version_number, 3007016i32 + ); } - ((*sqlite3_api).stmt_busy.expect(stringify!( + ((*p_api).stmt_busy.expect(stringify!( "sqlite3_api contains null pointer for ", "stmt_busy", " function" @@ -8521,10 +8960,19 @@ pub unsafe fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_in } pub unsafe fn sqlite3_stmt_readonly(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3007016i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_stmt_readonly, + " function" + ), + sqlite3_version_number, 3007016i32 + ); } - ((*sqlite3_api).stmt_readonly.expect(stringify!( + ((*p_api).stmt_readonly.expect(stringify!( "sqlite3_api contains null pointer for ", "stmt_readonly", " function" @@ -8535,10 +8983,19 @@ pub unsafe fn sqlite3_stricmp( arg1: *const ::std::os::raw::c_char, arg2: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3007016i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_stricmp, + " function" + ), + sqlite3_version_number, 3007016i32 + ); } - ((*sqlite3_api).stricmp.expect(stringify!( + ((*p_api).stricmp.expect(stringify!( "sqlite3_api contains null pointer for ", "stricmp", " function" @@ -8550,10 +9007,19 @@ pub unsafe fn sqlite3_uri_boolean( arg2: *const ::std::os::raw::c_char, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3007016i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_uri_boolean, + " function" + ), + sqlite3_version_number, 3007016i32 + ); } - ((*sqlite3_api).uri_boolean.expect(stringify!( + ((*p_api).uri_boolean.expect(stringify!( "sqlite3_api contains null pointer for ", "uri_boolean", " function" @@ -8565,10 +9031,19 @@ pub unsafe fn sqlite3_uri_int64( arg2: *const ::std::os::raw::c_char, arg3: sqlite3_int64, ) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3007016i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_uri_int64, + " function" + ), + sqlite3_version_number, 3007016i32 + ); } - ((*sqlite3_api).uri_int64.expect(stringify!( + ((*p_api).uri_int64.expect(stringify!( "sqlite3_api contains null pointer for ", "uri_int64", " function" @@ -8579,10 +9054,19 @@ pub unsafe fn sqlite3_uri_parameter( arg1: *const ::std::os::raw::c_char, arg2: *const ::std::os::raw::c_char, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3007016i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_uri_parameter, + " function" + ), + sqlite3_version_number, 3007016i32 + ); } - ((*sqlite3_api).uri_parameter.expect(stringify!( + ((*p_api).uri_parameter.expect(stringify!( "sqlite3_api contains null pointer for ", "uri_parameter", " function" @@ -8595,10 +9079,19 @@ pub unsafe fn sqlite3_vsnprintf( arg3: *const ::std::os::raw::c_char, arg4: *mut __va_list_tag, ) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3007016i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_vsnprintf, + " function" + ), + sqlite3_version_number, 3007016i32 + ); } - ((*sqlite3_api).vsnprintf.expect(stringify!( + ((*p_api).vsnprintf.expect(stringify!( "sqlite3_api contains null pointer for ", "vsnprintf", " function" @@ -8612,10 +9105,19 @@ pub unsafe fn sqlite3_wal_checkpoint_v2( arg4: *mut ::std::os::raw::c_int, arg5: *mut ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3007016i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_wal_checkpoint_v2, + " function" + ), + sqlite3_version_number, 3007016i32 + ); } - ((*sqlite3_api).wal_checkpoint_v2.expect(stringify!( + ((*p_api).wal_checkpoint_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "wal_checkpoint_v2", " function" diff --git a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7-ext.rs b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7-ext.rs index 6150cae8b..aab45af9c 100644 --- a/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7-ext.rs +++ b/libsqlite3-sys/bindgen-bindings/bindgen_3.7.7-ext.rs @@ -1,9 +1,9 @@ -/* automatically generated by rust-bindgen 0.57.0 */ +/* automatically generated by rust-bindgen 0.59.2 */ pub const __GNUC_VA_LIST: i32 = 1; -pub const SQLITE_VERSION: &'static [u8; 6usize] = b"3.7.7\0"; +pub const SQLITE_VERSION: &[u8; 6usize] = b"3.7.7\0"; pub const SQLITE_VERSION_NUMBER: i32 = 3007007; -pub const SQLITE_SOURCE_ID: &'static [u8; 61usize] = +pub const SQLITE_SOURCE_ID: &[u8; 61usize] = b"2011-06-23 19:49:22 4374b7e83ea0a3fbc3691f9c0c936272862f32f2\0"; pub const SQLITE_OK: i32 = 0; pub const SQLITE_ERROR: i32 = 1; @@ -5338,19 +5338,20 @@ fn bindgen_test_layout___va_list_tag() { ); } -// sqlite3_api is defined in lib.rs as either a static or an extern when compiled as a loadable_extension -use crate::sqlite3_api; +// The `loadable_extension_sqlite3_api` function is defined when compiled as a +// loadable_extension. It is used to safely access the static `SQLITE3_API` +// reference that is populated by a call to either`loadable_extension_init` +// or `loadable_extension_embedded_init` +use crate::loadable_extension_sqlite3_api; -// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from libsqlite3-sys/build.rs - not by rust-bindgen) pub unsafe fn sqlite3_aggregate_context( arg1: *mut sqlite3_context, nBytes: ::std::os::raw::c_int, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_context.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).aggregate_context.expect(stringify!( "sqlite3_api contains null pointer for ", "aggregate_context", " function" @@ -5358,10 +5359,8 @@ pub unsafe fn sqlite3_aggregate_context( } pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_count.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).aggregate_count.expect(stringify!( "sqlite3_api contains null pointer for ", "aggregate_count", " function" @@ -5375,10 +5374,8 @@ pub unsafe fn sqlite3_bind_blob( n: ::std::os::raw::c_int, arg4: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_blob.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_blob.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_blob", " function" @@ -5390,10 +5387,8 @@ pub unsafe fn sqlite3_bind_double( arg2: ::std::os::raw::c_int, arg3: f64, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_double.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_double.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_double", " function" @@ -5405,10 +5400,8 @@ pub unsafe fn sqlite3_bind_int( arg2: ::std::os::raw::c_int, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_int.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_int", " function" @@ -5420,10 +5413,8 @@ pub unsafe fn sqlite3_bind_int64( arg2: ::std::os::raw::c_int, arg3: sqlite_int64, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int64.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_int64.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_int64", " function" @@ -5434,10 +5425,8 @@ pub unsafe fn sqlite3_bind_null( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_null.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_null.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_null", " function" @@ -5445,10 +5434,8 @@ pub unsafe fn sqlite3_bind_null( } pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_count.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_parameter_count.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_parameter_count", " function" @@ -5459,10 +5446,8 @@ pub unsafe fn sqlite3_bind_parameter_index( arg1: *mut sqlite3_stmt, zName: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_index.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_parameter_index.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_parameter_index", " function" @@ -5473,10 +5458,8 @@ pub unsafe fn sqlite3_bind_parameter_name( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_name.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_parameter_name.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_parameter_name", " function" @@ -5490,10 +5473,8 @@ pub unsafe fn sqlite3_bind_text( n: ::std::os::raw::c_int, arg4: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_text.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_text", " function" @@ -5507,10 +5488,8 @@ pub unsafe fn sqlite3_bind_text16( arg4: ::std::os::raw::c_int, arg5: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_text16.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_text16", " function" @@ -5522,10 +5501,8 @@ pub unsafe fn sqlite3_bind_value( arg2: ::std::os::raw::c_int, arg3: *const sqlite3_value, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_value.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_value.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_value", " function" @@ -5542,10 +5519,8 @@ pub unsafe fn sqlite3_busy_handler( >, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_handler.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).busy_handler.expect(stringify!( "sqlite3_api contains null pointer for ", "busy_handler", " function" @@ -5556,10 +5531,8 @@ pub unsafe fn sqlite3_busy_timeout( arg1: *mut sqlite3, ms: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_timeout.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).busy_timeout.expect(stringify!( "sqlite3_api contains null pointer for ", "busy_timeout", " function" @@ -5567,10 +5540,8 @@ pub unsafe fn sqlite3_busy_timeout( } pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).changes.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).changes.expect(stringify!( "sqlite3_api contains null pointer for ", "changes", " function" @@ -5578,10 +5549,8 @@ pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { } pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).close.expect(stringify!( "sqlite3_api contains null pointer for ", "close", " function" @@ -5600,10 +5569,8 @@ pub unsafe fn sqlite3_collation_needed( ), >, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).collation_needed.expect(stringify!( "sqlite3_api contains null pointer for ", "collation_needed", " function" @@ -5622,10 +5589,8 @@ pub unsafe fn sqlite3_collation_needed16( ), >, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).collation_needed16.expect(stringify!( "sqlite3_api contains null pointer for ", "collation_needed16", " function" @@ -5636,10 +5601,8 @@ pub unsafe fn sqlite3_column_blob( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_blob.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_blob.expect(stringify!( "sqlite3_api contains null pointer for ", "column_blob", " function" @@ -5650,10 +5613,8 @@ pub unsafe fn sqlite3_column_bytes( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_bytes.expect(stringify!( "sqlite3_api contains null pointer for ", "column_bytes", " function" @@ -5664,10 +5625,8 @@ pub unsafe fn sqlite3_column_bytes16( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_bytes16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_bytes16", " function" @@ -5675,10 +5634,8 @@ pub unsafe fn sqlite3_column_bytes16( } pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_count.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_count.expect(stringify!( "sqlite3_api contains null pointer for ", "column_count", " function" @@ -5689,10 +5646,8 @@ pub unsafe fn sqlite3_column_database_name( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_database_name.expect(stringify!( "sqlite3_api contains null pointer for ", "column_database_name", " function" @@ -5703,10 +5658,8 @@ pub unsafe fn sqlite3_column_database_name16( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_database_name16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_database_name16", " function" @@ -5717,10 +5670,8 @@ pub unsafe fn sqlite3_column_decltype( arg1: *mut sqlite3_stmt, i: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_decltype.expect(stringify!( "sqlite3_api contains null pointer for ", "column_decltype", " function" @@ -5731,10 +5682,8 @@ pub unsafe fn sqlite3_column_decltype16( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_decltype16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_decltype16", " function" @@ -5742,10 +5691,8 @@ pub unsafe fn sqlite3_column_decltype16( } pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_double.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_double.expect(stringify!( "sqlite3_api contains null pointer for ", "column_double", " function" @@ -5756,10 +5703,8 @@ pub unsafe fn sqlite3_column_int( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_int.expect(stringify!( "sqlite3_api contains null pointer for ", "column_int", " function" @@ -5770,10 +5715,8 @@ pub unsafe fn sqlite3_column_int64( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int64.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_int64.expect(stringify!( "sqlite3_api contains null pointer for ", "column_int64", " function" @@ -5784,10 +5727,8 @@ pub unsafe fn sqlite3_column_name( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_name.expect(stringify!( "sqlite3_api contains null pointer for ", "column_name", " function" @@ -5798,10 +5739,8 @@ pub unsafe fn sqlite3_column_name16( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_name16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_name16", " function" @@ -5812,10 +5751,8 @@ pub unsafe fn sqlite3_column_origin_name( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_origin_name.expect(stringify!( "sqlite3_api contains null pointer for ", "column_origin_name", " function" @@ -5826,10 +5763,8 @@ pub unsafe fn sqlite3_column_origin_name16( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_origin_name16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_origin_name16", " function" @@ -5840,10 +5775,8 @@ pub unsafe fn sqlite3_column_table_name( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_table_name.expect(stringify!( "sqlite3_api contains null pointer for ", "column_table_name", " function" @@ -5854,10 +5787,8 @@ pub unsafe fn sqlite3_column_table_name16( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_table_name16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_table_name16", " function" @@ -5868,10 +5799,8 @@ pub unsafe fn sqlite3_column_text( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_text.expect(stringify!( "sqlite3_api contains null pointer for ", "column_text", " function" @@ -5882,10 +5811,8 @@ pub unsafe fn sqlite3_column_text16( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_text16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_text16", " function" @@ -5896,10 +5823,8 @@ pub unsafe fn sqlite3_column_type( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_type.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_type.expect(stringify!( "sqlite3_api contains null pointer for ", "column_type", " function" @@ -5910,10 +5835,8 @@ pub unsafe fn sqlite3_column_value( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_value.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_value.expect(stringify!( "sqlite3_api contains null pointer for ", "column_value", " function" @@ -5927,10 +5850,8 @@ pub unsafe fn sqlite3_commit_hook( >, arg3: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).commit_hook.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).commit_hook.expect(stringify!( "sqlite3_api contains null pointer for ", "commit_hook", " function" @@ -5938,10 +5859,8 @@ pub unsafe fn sqlite3_commit_hook( } pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).complete.expect(stringify!( "sqlite3_api contains null pointer for ", "complete", " function" @@ -5949,10 +5868,8 @@ pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os: } pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).complete16.expect(stringify!( "sqlite3_api contains null pointer for ", "complete16", " function" @@ -5974,10 +5891,8 @@ pub unsafe fn sqlite3_create_collation( ) -> ::std::os::raw::c_int, >, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).create_collation.expect(stringify!( "sqlite3_api contains null pointer for ", "create_collation", " function" @@ -5999,10 +5914,8 @@ pub unsafe fn sqlite3_create_collation16( ) -> ::std::os::raw::c_int, >, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).create_collation16.expect(stringify!( "sqlite3_api contains null pointer for ", "create_collation16", " function" @@ -6031,10 +5944,8 @@ pub unsafe fn sqlite3_create_function( >, xFinal: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).create_function.expect(stringify!( "sqlite3_api contains null pointer for ", "create_function", " function" @@ -6063,10 +5974,8 @@ pub unsafe fn sqlite3_create_function16( >, xFinal: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).create_function16.expect(stringify!( "sqlite3_api contains null pointer for ", "create_function16", " function" @@ -6079,10 +5988,8 @@ pub unsafe fn sqlite3_create_module( arg3: *const sqlite3_module, arg4: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).create_module.expect(stringify!( "sqlite3_api contains null pointer for ", "create_module", " function" @@ -6090,10 +5997,8 @@ pub unsafe fn sqlite3_create_module( } pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).data_count.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).data_count.expect(stringify!( "sqlite3_api contains null pointer for ", "data_count", " function" @@ -6101,10 +6006,8 @@ pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_ } pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_handle.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).db_handle.expect(stringify!( "sqlite3_api contains null pointer for ", "db_handle", " function" @@ -6115,10 +6018,8 @@ pub unsafe fn sqlite3_declare_vtab( arg1: *mut sqlite3, arg2: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).declare_vtab.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).declare_vtab.expect(stringify!( "sqlite3_api contains null pointer for ", "declare_vtab", " function" @@ -6126,10 +6027,8 @@ pub unsafe fn sqlite3_declare_vtab( } pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).enable_shared_cache.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).enable_shared_cache.expect(stringify!( "sqlite3_api contains null pointer for ", "enable_shared_cache", " function" @@ -6137,10 +6036,8 @@ pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std: } pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errcode.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).errcode.expect(stringify!( "sqlite3_api contains null pointer for ", "errcode", " function" @@ -6148,10 +6045,8 @@ pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { } pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).errmsg.expect(stringify!( "sqlite3_api contains null pointer for ", "errmsg", " function" @@ -6159,10 +6054,8 @@ pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_cha } pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).errmsg16.expect(stringify!( "sqlite3_api contains null pointer for ", "errmsg16", " function" @@ -6176,10 +6069,8 @@ pub unsafe fn sqlite3_exec( arg4: *mut ::std::os::raw::c_void, arg5: *mut *mut ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).exec.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).exec.expect(stringify!( "sqlite3_api contains null pointer for ", "exec", " function" @@ -6187,10 +6078,8 @@ pub unsafe fn sqlite3_exec( } pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).expired.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).expired.expect(stringify!( "sqlite3_api contains null pointer for ", "expired", " function" @@ -6198,10 +6087,8 @@ pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int } pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).finalize.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).finalize.expect(stringify!( "sqlite3_api contains null pointer for ", "finalize", " function" @@ -6209,10 +6096,8 @@ pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_in } pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).free.expect(stringify!( "sqlite3_api contains null pointer for ", "free", " function" @@ -6220,10 +6105,8 @@ pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { } pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free_table.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).free_table.expect(stringify!( "sqlite3_api contains null pointer for ", "free_table", " function" @@ -6231,10 +6114,8 @@ pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { } pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_autocommit.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).get_autocommit.expect(stringify!( "sqlite3_api contains null pointer for ", "get_autocommit", " function" @@ -6245,10 +6126,8 @@ pub unsafe fn sqlite3_get_auxdata( arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_auxdata.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).get_auxdata.expect(stringify!( "sqlite3_api contains null pointer for ", "get_auxdata", " function" @@ -6263,10 +6142,8 @@ pub unsafe fn sqlite3_get_table( arg5: *mut ::std::os::raw::c_int, arg6: *mut *mut ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_table.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).get_table.expect(stringify!( "sqlite3_api contains null pointer for ", "get_table", " function" @@ -6274,10 +6151,8 @@ pub unsafe fn sqlite3_get_table( } pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).global_recover.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).global_recover.expect(stringify!( "sqlite3_api contains null pointer for ", "global_recover", " function" @@ -6285,10 +6160,8 @@ pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { } pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).interruptx.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).interruptx.expect(stringify!( "sqlite3_api contains null pointer for ", "interruptx", " function" @@ -6296,10 +6169,8 @@ pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { } pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).last_insert_rowid.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).last_insert_rowid.expect(stringify!( "sqlite3_api contains null pointer for ", "last_insert_rowid", " function" @@ -6307,10 +6178,8 @@ pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { } pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).libversion.expect(stringify!( "sqlite3_api contains null pointer for ", "libversion", " function" @@ -6318,10 +6187,8 @@ pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { } pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion_number.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).libversion_number.expect(stringify!( "sqlite3_api contains null pointer for ", "libversion_number", " function" @@ -6329,10 +6196,8 @@ pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { } pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).malloc.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).malloc.expect(stringify!( "sqlite3_api contains null pointer for ", "malloc", " function" @@ -6340,10 +6205,8 @@ pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw } pub unsafe fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mprintf.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).mprintf.expect(stringify!( "sqlite3_api contains null pointer for ", "mprintf", " function" @@ -6354,10 +6217,8 @@ pub unsafe fn sqlite3_open( arg1: *const ::std::os::raw::c_char, arg2: *mut *mut sqlite3, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).open.expect(stringify!( "sqlite3_api contains null pointer for ", "open", " function" @@ -6368,10 +6229,8 @@ pub unsafe fn sqlite3_open16( arg1: *const ::std::os::raw::c_void, arg2: *mut *mut sqlite3, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).open16.expect(stringify!( "sqlite3_api contains null pointer for ", "open16", " function" @@ -6385,10 +6244,8 @@ pub unsafe fn sqlite3_prepare( arg4: *mut *mut sqlite3_stmt, arg5: *mut *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).prepare.expect(stringify!( "sqlite3_api contains null pointer for ", "prepare", " function" @@ -6402,10 +6259,8 @@ pub unsafe fn sqlite3_prepare16( arg4: *mut *mut sqlite3_stmt, arg5: *mut *const ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).prepare16.expect(stringify!( "sqlite3_api contains null pointer for ", "prepare16", " function" @@ -6423,10 +6278,8 @@ pub unsafe fn sqlite3_profile( >, arg3: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).profile.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).profile.expect(stringify!( "sqlite3_api contains null pointer for ", "profile", " function" @@ -6441,10 +6294,8 @@ pub unsafe fn sqlite3_progress_handler( >, arg4: *mut ::std::os::raw::c_void, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).progress_handler.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).progress_handler.expect(stringify!( "sqlite3_api contains null pointer for ", "progress_handler", " function" @@ -6455,10 +6306,8 @@ pub unsafe fn sqlite3_realloc( arg1: *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).realloc.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).realloc.expect(stringify!( "sqlite3_api contains null pointer for ", "realloc", " function" @@ -6466,10 +6315,8 @@ pub unsafe fn sqlite3_realloc( } pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).reset.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).reset.expect(stringify!( "sqlite3_api contains null pointer for ", "reset", " function" @@ -6482,10 +6329,8 @@ pub unsafe fn sqlite3_result_blob( arg3: ::std::os::raw::c_int, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_blob.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_blob.expect(stringify!( "sqlite3_api contains null pointer for ", "result_blob", " function" @@ -6493,10 +6338,8 @@ pub unsafe fn sqlite3_result_blob( } pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_double.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_double.expect(stringify!( "sqlite3_api contains null pointer for ", "result_double", " function" @@ -6508,10 +6351,8 @@ pub unsafe fn sqlite3_result_error( arg2: *const ::std::os::raw::c_char, arg3: ::std::os::raw::c_int, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_error.expect(stringify!( "sqlite3_api contains null pointer for ", "result_error", " function" @@ -6523,10 +6364,8 @@ pub unsafe fn sqlite3_result_error16( arg2: *const ::std::os::raw::c_void, arg3: ::std::os::raw::c_int, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_error16.expect(stringify!( "sqlite3_api contains null pointer for ", "result_error16", " function" @@ -6534,10 +6373,8 @@ pub unsafe fn sqlite3_result_error16( } pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_int.expect(stringify!( "sqlite3_api contains null pointer for ", "result_int", " function" @@ -6545,10 +6382,8 @@ pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::ra } pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int64.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_int64.expect(stringify!( "sqlite3_api contains null pointer for ", "result_int64", " function" @@ -6556,10 +6391,8 @@ pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int6 } pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_null.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_null.expect(stringify!( "sqlite3_api contains null pointer for ", "result_null", " function" @@ -6572,10 +6405,8 @@ pub unsafe fn sqlite3_result_text( arg3: ::std::os::raw::c_int, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_text.expect(stringify!( "sqlite3_api contains null pointer for ", "result_text", " function" @@ -6588,10 +6419,8 @@ pub unsafe fn sqlite3_result_text16( arg3: ::std::os::raw::c_int, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_text16.expect(stringify!( "sqlite3_api contains null pointer for ", "result_text16", " function" @@ -6604,10 +6433,8 @@ pub unsafe fn sqlite3_result_text16be( arg3: ::std::os::raw::c_int, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16be.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_text16be.expect(stringify!( "sqlite3_api contains null pointer for ", "result_text16be", " function" @@ -6620,10 +6447,8 @@ pub unsafe fn sqlite3_result_text16le( arg3: ::std::os::raw::c_int, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16le.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_text16le.expect(stringify!( "sqlite3_api contains null pointer for ", "result_text16le", " function" @@ -6631,10 +6456,8 @@ pub unsafe fn sqlite3_result_text16le( } pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_value.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_value.expect(stringify!( "sqlite3_api contains null pointer for ", "result_value", " function" @@ -6646,10 +6469,8 @@ pub unsafe fn sqlite3_rollback_hook( arg2: ::std::option::Option, arg3: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).rollback_hook.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).rollback_hook.expect(stringify!( "sqlite3_api contains null pointer for ", "rollback_hook", " function" @@ -6670,10 +6491,8 @@ pub unsafe fn sqlite3_set_authorizer( >, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_authorizer.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).set_authorizer.expect(stringify!( "sqlite3_api contains null pointer for ", "set_authorizer", " function" @@ -6686,10 +6505,8 @@ pub unsafe fn sqlite3_set_auxdata( arg3: *mut ::std::os::raw::c_void, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_auxdata.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).set_auxdata.expect(stringify!( "sqlite3_api contains null pointer for ", "set_auxdata", " function" @@ -6701,10 +6518,8 @@ pub unsafe fn sqlite3_snprintf( arg2: *mut ::std::os::raw::c_char, arg3: *const ::std::os::raw::c_char, ) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).snprintf.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).snprintf.expect(stringify!( "sqlite3_api contains null pointer for ", "snprintf", " function" @@ -6712,10 +6527,8 @@ pub unsafe fn sqlite3_snprintf( } pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).step.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).step.expect(stringify!( "sqlite3_api contains null pointer for ", "step", " function" @@ -6733,10 +6546,8 @@ pub unsafe fn sqlite3_table_column_metadata( arg8: *mut ::std::os::raw::c_int, arg9: *mut ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).table_column_metadata.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).table_column_metadata.expect(stringify!( "sqlite3_api contains null pointer for ", "table_column_metadata", " function" @@ -6744,10 +6555,8 @@ pub unsafe fn sqlite3_table_column_metadata( } pub unsafe fn sqlite3_thread_cleanup() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).thread_cleanup.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).thread_cleanup.expect(stringify!( "sqlite3_api contains null pointer for ", "thread_cleanup", " function" @@ -6755,10 +6564,8 @@ pub unsafe fn sqlite3_thread_cleanup() { } pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).total_changes.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).total_changes.expect(stringify!( "sqlite3_api contains null pointer for ", "total_changes", " function" @@ -6775,10 +6582,8 @@ pub unsafe fn sqlite3_trace( >, arg2: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).trace.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).trace.expect(stringify!( "sqlite3_api contains null pointer for ", "trace", " function" @@ -6789,10 +6594,8 @@ pub unsafe fn sqlite3_transfer_bindings( arg1: *mut sqlite3_stmt, arg2: *mut sqlite3_stmt, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).transfer_bindings.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).transfer_bindings.expect(stringify!( "sqlite3_api contains null pointer for ", "transfer_bindings", " function" @@ -6812,10 +6615,8 @@ pub unsafe fn sqlite3_update_hook( >, arg3: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).update_hook.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).update_hook.expect(stringify!( "sqlite3_api contains null pointer for ", "update_hook", " function" @@ -6823,10 +6624,8 @@ pub unsafe fn sqlite3_update_hook( } pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).user_data.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).user_data.expect(stringify!( "sqlite3_api contains null pointer for ", "user_data", " function" @@ -6834,10 +6633,8 @@ pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::r } pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_blob.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_blob.expect(stringify!( "sqlite3_api contains null pointer for ", "value_blob", " function" @@ -6845,10 +6642,8 @@ pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os:: } pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_bytes.expect(stringify!( "sqlite3_api contains null pointer for ", "value_bytes", " function" @@ -6856,10 +6651,8 @@ pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c } pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_bytes16.expect(stringify!( "sqlite3_api contains null pointer for ", "value_bytes16", " function" @@ -6867,10 +6660,8 @@ pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw: } pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_double.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_double.expect(stringify!( "sqlite3_api contains null pointer for ", "value_double", " function" @@ -6878,10 +6669,8 @@ pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { } pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_int.expect(stringify!( "sqlite3_api contains null pointer for ", "value_int", " function" @@ -6889,10 +6678,8 @@ pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_i } pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int64.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_int64.expect(stringify!( "sqlite3_api contains null pointer for ", "value_int64", " function" @@ -6900,10 +6687,8 @@ pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { } pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_numeric_type.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_numeric_type.expect(stringify!( "sqlite3_api contains null pointer for ", "value_numeric_type", " function" @@ -6911,10 +6696,8 @@ pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os: } pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_text.expect(stringify!( "sqlite3_api contains null pointer for ", "value_text", " function" @@ -6922,10 +6705,8 @@ pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os:: } pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_text16.expect(stringify!( "sqlite3_api contains null pointer for ", "value_text16", " function" @@ -6933,10 +6714,8 @@ pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os } pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16be.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_text16be.expect(stringify!( "sqlite3_api contains null pointer for ", "value_text16be", " function" @@ -6944,10 +6723,8 @@ pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std:: } pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16le.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_text16le.expect(stringify!( "sqlite3_api contains null pointer for ", "value_text16le", " function" @@ -6955,10 +6732,8 @@ pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std:: } pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_type.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_type.expect(stringify!( "sqlite3_api contains null pointer for ", "value_type", " function" @@ -6969,10 +6744,8 @@ pub unsafe fn sqlite3_vmprintf( arg1: *const ::std::os::raw::c_char, arg2: *mut __va_list_tag, ) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).vmprintf.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).vmprintf.expect(stringify!( "sqlite3_api contains null pointer for ", "vmprintf", " function" @@ -6984,10 +6757,19 @@ pub unsafe fn sqlite3_overload_function( zFuncName: *const ::std::os::raw::c_char, nArg: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3003013i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_overload_function, + " function" + ), + sqlite3_version_number, 3003013i32 + ); } - ((*sqlite3_api).overload_function.expect(stringify!( + ((*p_api).overload_function.expect(stringify!( "sqlite3_api contains null pointer for ", "overload_function", " function" @@ -7001,10 +6783,19 @@ pub unsafe fn sqlite3_prepare_v2( arg4: *mut *mut sqlite3_stmt, arg5: *mut *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3003013i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_prepare_v2, + " function" + ), + sqlite3_version_number, 3003013i32 + ); } - ((*sqlite3_api).prepare_v2.expect(stringify!( + ((*p_api).prepare_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "prepare_v2", " function" @@ -7018,10 +6809,19 @@ pub unsafe fn sqlite3_prepare16_v2( arg4: *mut *mut sqlite3_stmt, arg5: *mut *const ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3003013i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_prepare16_v2, + " function" + ), + sqlite3_version_number, 3003013i32 + ); } - ((*sqlite3_api).prepare16_v2.expect(stringify!( + ((*p_api).prepare16_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "prepare16_v2", " function" @@ -7029,10 +6829,19 @@ pub unsafe fn sqlite3_prepare16_v2( } pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3003013i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_clear_bindings, + " function" + ), + sqlite3_version_number, 3003013i32 + ); } - ((*sqlite3_api).clear_bindings.expect(stringify!( + ((*p_api).clear_bindings.expect(stringify!( "sqlite3_api contains null pointer for ", "clear_bindings", " function" @@ -7046,10 +6855,19 @@ pub unsafe fn sqlite3_create_module_v2( arg4: *mut ::std::os::raw::c_void, xDestroy: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3004001i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_create_module_v2, + " function" + ), + sqlite3_version_number, 3004001i32 + ); } - ((*sqlite3_api).create_module_v2.expect(stringify!( + ((*p_api).create_module_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "create_module_v2", " function" @@ -7061,10 +6879,19 @@ pub unsafe fn sqlite3_bind_zeroblob( arg2: ::std::os::raw::c_int, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_bind_zeroblob, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).bind_zeroblob.expect(stringify!( + ((*p_api).bind_zeroblob.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_zeroblob", " function" @@ -7072,10 +6899,19 @@ pub unsafe fn sqlite3_bind_zeroblob( } pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_bytes, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_bytes.expect(stringify!( + ((*p_api).blob_bytes.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_bytes", " function" @@ -7083,10 +6919,19 @@ pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_i } pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_close, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_close.expect(stringify!( + ((*p_api).blob_close.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_close", " function" @@ -7102,10 +6947,19 @@ pub unsafe fn sqlite3_blob_open( arg6: ::std::os::raw::c_int, arg7: *mut *mut sqlite3_blob, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_open, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_open.expect(stringify!( + ((*p_api).blob_open.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_open", " function" @@ -7118,10 +6972,19 @@ pub unsafe fn sqlite3_blob_read( arg3: ::std::os::raw::c_int, arg4: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_read, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_read.expect(stringify!( + ((*p_api).blob_read.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_read", " function" @@ -7134,10 +6997,19 @@ pub unsafe fn sqlite3_blob_write( arg3: ::std::os::raw::c_int, arg4: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_write, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_write.expect(stringify!( + ((*p_api).blob_write.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_write", " function" @@ -7160,10 +7032,19 @@ pub unsafe fn sqlite3_create_collation_v2( >, arg6: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_create_collation_v2, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).create_collation_v2.expect(stringify!( + ((*p_api).create_collation_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "create_collation_v2", " function" @@ -7176,10 +7057,19 @@ pub unsafe fn sqlite3_file_control( arg3: ::std::os::raw::c_int, arg4: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_file_control, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).file_control.expect(stringify!( + ((*p_api).file_control.expect(stringify!( "sqlite3_api contains null pointer for ", "file_control", " function" @@ -7187,10 +7077,19 @@ pub unsafe fn sqlite3_file_control( } pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_memory_highwater, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).memory_highwater.expect(stringify!( + ((*p_api).memory_highwater.expect(stringify!( "sqlite3_api contains null pointer for ", "memory_highwater", " function" @@ -7198,10 +7097,19 @@ pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_i } pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_memory_used, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).memory_used.expect(stringify!( + ((*p_api).memory_used.expect(stringify!( "sqlite3_api contains null pointer for ", "memory_used", " function" @@ -7209,10 +7117,19 @@ pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { } pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_mutex_alloc, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).mutex_alloc.expect(stringify!( + ((*p_api).mutex_alloc.expect(stringify!( "sqlite3_api contains null pointer for ", "mutex_alloc", " function" @@ -7220,10 +7137,19 @@ pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_m } pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_mutex_enter, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).mutex_enter.expect(stringify!( + ((*p_api).mutex_enter.expect(stringify!( "sqlite3_api contains null pointer for ", "mutex_enter", " function" @@ -7231,10 +7157,19 @@ pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { } pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_mutex_free, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).mutex_free.expect(stringify!( + ((*p_api).mutex_free.expect(stringify!( "sqlite3_api contains null pointer for ", "mutex_free", " function" @@ -7242,10 +7177,19 @@ pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { } pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_mutex_leave, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).mutex_leave.expect(stringify!( + ((*p_api).mutex_leave.expect(stringify!( "sqlite3_api contains null pointer for ", "mutex_leave", " function" @@ -7253,10 +7197,19 @@ pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { } pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_mutex_try, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).mutex_try.expect(stringify!( + ((*p_api).mutex_try.expect(stringify!( "sqlite3_api contains null pointer for ", "mutex_try", " function" @@ -7269,10 +7222,19 @@ pub unsafe fn sqlite3_open_v2( arg3: ::std::os::raw::c_int, arg4: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_open_v2, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).open_v2.expect(stringify!( + ((*p_api).open_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "open_v2", " function" @@ -7280,10 +7242,19 @@ pub unsafe fn sqlite3_open_v2( } pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_release_memory, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).release_memory.expect(stringify!( + ((*p_api).release_memory.expect(stringify!( "sqlite3_api contains null pointer for ", "release_memory", " function" @@ -7291,10 +7262,19 @@ pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os:: } pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_result_error_nomem, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).result_error_nomem.expect(stringify!( + ((*p_api).result_error_nomem.expect(stringify!( "sqlite3_api contains null pointer for ", "result_error_nomem", " function" @@ -7302,10 +7282,19 @@ pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { } pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_result_error_toobig, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).result_error_toobig.expect(stringify!( + ((*p_api).result_error_toobig.expect(stringify!( "sqlite3_api contains null pointer for ", "result_error_toobig", " function" @@ -7313,10 +7302,19 @@ pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { } pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_sleep, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).sleep.expect(stringify!( + ((*p_api).sleep.expect(stringify!( "sqlite3_api contains null pointer for ", "sleep", " function" @@ -7324,10 +7322,19 @@ pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_in } pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_soft_heap_limit, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).soft_heap_limit.expect(stringify!( + ((*p_api).soft_heap_limit.expect(stringify!( "sqlite3_api contains null pointer for ", "soft_heap_limit", " function" @@ -7335,10 +7342,19 @@ pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { } pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_vfs_find, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).vfs_find.expect(stringify!( + ((*p_api).vfs_find.expect(stringify!( "sqlite3_api contains null pointer for ", "vfs_find", " function" @@ -7349,10 +7365,19 @@ pub unsafe fn sqlite3_vfs_register( arg1: *mut sqlite3_vfs, arg2: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_vfs_register, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).vfs_register.expect(stringify!( + ((*p_api).vfs_register.expect(stringify!( "sqlite3_api contains null pointer for ", "vfs_register", " function" @@ -7360,10 +7385,19 @@ pub unsafe fn sqlite3_vfs_register( } pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_vfs_unregister, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).vfs_unregister.expect(stringify!( + ((*p_api).vfs_unregister.expect(stringify!( "sqlite3_api contains null pointer for ", "vfs_unregister", " function" @@ -7371,10 +7405,19 @@ pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw:: } pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_xthreadsafe, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).xthreadsafe.expect(stringify!( + ((*p_api).xthreadsafe.expect(stringify!( "sqlite3_api contains null pointer for ", "xthreadsafe", " function" @@ -7382,10 +7425,19 @@ pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { } pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_result_zeroblob, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).result_zeroblob.expect(stringify!( + ((*p_api).result_zeroblob.expect(stringify!( "sqlite3_api contains null pointer for ", "result_zeroblob", " function" @@ -7393,10 +7445,19 @@ pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::o } pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_result_error_code, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).result_error_code.expect(stringify!( + ((*p_api).result_error_code.expect(stringify!( "sqlite3_api contains null pointer for ", "result_error_code", " function" @@ -7404,10 +7465,19 @@ pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std: } pub unsafe fn sqlite3_test_control(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_test_control, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).test_control.expect(stringify!( + ((*p_api).test_control.expect(stringify!( "sqlite3_api contains null pointer for ", "test_control", " function" @@ -7415,10 +7485,19 @@ pub unsafe fn sqlite3_test_control(arg1: ::std::os::raw::c_int) -> ::std::os::ra } pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_randomness, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).randomness.expect(stringify!( + ((*p_api).randomness.expect(stringify!( "sqlite3_api contains null pointer for ", "randomness", " function" @@ -7426,10 +7505,19 @@ pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std:: } pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_context_db_handle, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).context_db_handle.expect(stringify!( + ((*p_api).context_db_handle.expect(stringify!( "sqlite3_api contains null pointer for ", "context_db_handle", " function" @@ -7440,10 +7528,19 @@ pub unsafe fn sqlite3_extended_result_codes( arg1: *mut sqlite3, arg2: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_extended_result_codes, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).extended_result_codes.expect(stringify!( + ((*p_api).extended_result_codes.expect(stringify!( "sqlite3_api contains null pointer for ", "extended_result_codes", " function" @@ -7455,10 +7552,19 @@ pub unsafe fn sqlite3_limit( arg2: ::std::os::raw::c_int, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_limit, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).limit.expect(stringify!( + ((*p_api).limit.expect(stringify!( "sqlite3_api contains null pointer for ", "limit", " function" @@ -7466,10 +7572,19 @@ pub unsafe fn sqlite3_limit( } pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_next_stmt, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).next_stmt.expect(stringify!( + ((*p_api).next_stmt.expect(stringify!( "sqlite3_api contains null pointer for ", "next_stmt", " function" @@ -7477,10 +7592,19 @@ pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> } pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_sql, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).sql.expect(stringify!( + ((*p_api).sql.expect(stringify!( "sqlite3_api contains null pointer for ", "sql", " function" @@ -7493,10 +7617,19 @@ pub unsafe fn sqlite3_status( arg3: *mut ::std::os::raw::c_int, arg4: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_status, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).status.expect(stringify!( + ((*p_api).status.expect(stringify!( "sqlite3_api contains null pointer for ", "status", " function" @@ -7504,10 +7637,19 @@ pub unsafe fn sqlite3_status( } pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_backup_finish, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).backup_finish.expect(stringify!( + ((*p_api).backup_finish.expect(stringify!( "sqlite3_api contains null pointer for ", "backup_finish", " function" @@ -7520,10 +7662,19 @@ pub unsafe fn sqlite3_backup_init( arg3: *mut sqlite3, arg4: *const ::std::os::raw::c_char, ) -> *mut sqlite3_backup { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_backup_init, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).backup_init.expect(stringify!( + ((*p_api).backup_init.expect(stringify!( "sqlite3_api contains null pointer for ", "backup_init", " function" @@ -7531,10 +7682,19 @@ pub unsafe fn sqlite3_backup_init( } pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_backup_pagecount, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).backup_pagecount.expect(stringify!( + ((*p_api).backup_pagecount.expect(stringify!( "sqlite3_api contains null pointer for ", "backup_pagecount", " function" @@ -7542,10 +7702,19 @@ pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os:: } pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_backup_remaining, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).backup_remaining.expect(stringify!( + ((*p_api).backup_remaining.expect(stringify!( "sqlite3_api contains null pointer for ", "backup_remaining", " function" @@ -7556,10 +7725,19 @@ pub unsafe fn sqlite3_backup_step( arg1: *mut sqlite3_backup, arg2: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_backup_step, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).backup_step.expect(stringify!( + ((*p_api).backup_step.expect(stringify!( "sqlite3_api contains null pointer for ", "backup_step", " function" @@ -7569,10 +7747,19 @@ pub unsafe fn sqlite3_backup_step( pub unsafe fn sqlite3_compileoption_get( arg1: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_compileoption_get, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).compileoption_get.expect(stringify!( + ((*p_api).compileoption_get.expect(stringify!( "sqlite3_api contains null pointer for ", "compileoption_get", " function" @@ -7582,10 +7769,19 @@ pub unsafe fn sqlite3_compileoption_get( pub unsafe fn sqlite3_compileoption_used( arg1: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_compileoption_used, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).compileoption_used.expect(stringify!( + ((*p_api).compileoption_used.expect(stringify!( "sqlite3_api contains null pointer for ", "compileoption_used", " function" @@ -7615,10 +7811,19 @@ pub unsafe fn sqlite3_create_function_v2( xFinal: ::std::option::Option, xDestroy: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_create_function_v2, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).create_function_v2.expect(stringify!( + ((*p_api).create_function_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "create_function_v2", " function" @@ -7629,10 +7834,19 @@ pub unsafe fn sqlite3_db_config( arg1: *mut sqlite3, arg2: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_db_config, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).db_config.expect(stringify!( + ((*p_api).db_config.expect(stringify!( "sqlite3_api contains null pointer for ", "db_config", " function" @@ -7644,10 +7858,19 @@ pub unsafe fn sqlite3_db_config_constchar( arg2: ::std::os::raw::c_int, vararg1: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_db_config_constchar, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).db_config.expect(stringify!( + ((*p_api).db_config.expect(stringify!( "sqlite3_api contains null pointer for ", "db_config", " function" @@ -7660,10 +7883,19 @@ pub unsafe fn sqlite3_db_config_int_mutint( vararg1: ::std::os::raw::c_int, vararg2: *mut ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_db_config_int_mutint, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).db_config.expect(stringify!( + ((*p_api).db_config.expect(stringify!( "sqlite3_api contains null pointer for ", "db_config", " function" @@ -7677,10 +7909,19 @@ pub unsafe fn sqlite3_db_config_void_int_mutint( vararg2: ::std::os::raw::c_int, vararg3: *mut ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_db_config_void_int_mutint, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).db_config.expect(stringify!( + ((*p_api).db_config.expect(stringify!( "sqlite3_api contains null pointer for ", "db_config", " function" @@ -7688,10 +7929,19 @@ pub unsafe fn sqlite3_db_config_void_int_mutint( } pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_db_mutex, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).db_mutex.expect(stringify!( + ((*p_api).db_mutex.expect(stringify!( "sqlite3_api contains null pointer for ", "db_mutex", " function" @@ -7705,10 +7955,19 @@ pub unsafe fn sqlite3_db_status( arg4: *mut ::std::os::raw::c_int, arg5: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_db_status, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).db_status.expect(stringify!( + ((*p_api).db_status.expect(stringify!( "sqlite3_api contains null pointer for ", "db_status", " function" @@ -7716,10 +7975,19 @@ pub unsafe fn sqlite3_db_status( } pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_extended_errcode, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).extended_errcode.expect(stringify!( + ((*p_api).extended_errcode.expect(stringify!( "sqlite3_api contains null pointer for ", "extended_errcode", " function" @@ -7727,10 +7995,19 @@ pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_ } pub unsafe fn sqlite3_log(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_log, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).log.expect(stringify!( + ((*p_api).log.expect(stringify!( "sqlite3_api contains null pointer for ", "log", " function" @@ -7738,10 +8015,19 @@ pub unsafe fn sqlite3_log(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::r } pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_soft_heap_limit64, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).soft_heap_limit64.expect(stringify!( + ((*p_api).soft_heap_limit64.expect(stringify!( "sqlite3_api contains null pointer for ", "soft_heap_limit64", " function" @@ -7749,10 +8035,19 @@ pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { } pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_sourceid, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).sourceid.expect(stringify!( + ((*p_api).sourceid.expect(stringify!( "sqlite3_api contains null pointer for ", "sourceid", " function" @@ -7764,10 +8059,19 @@ pub unsafe fn sqlite3_stmt_status( arg2: ::std::os::raw::c_int, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_stmt_status, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).stmt_status.expect(stringify!( + ((*p_api).stmt_status.expect(stringify!( "sqlite3_api contains null pointer for ", "stmt_status", " function" @@ -7779,10 +8083,19 @@ pub unsafe fn sqlite3_strnicmp( arg2: *const ::std::os::raw::c_char, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_strnicmp, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).strnicmp.expect(stringify!( + ((*p_api).strnicmp.expect(stringify!( "sqlite3_api contains null pointer for ", "strnicmp", " function" @@ -7796,10 +8109,19 @@ pub unsafe fn sqlite3_unlock_notify( >, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_unlock_notify, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).unlock_notify.expect(stringify!( + ((*p_api).unlock_notify.expect(stringify!( "sqlite3_api contains null pointer for ", "unlock_notify", " function" @@ -7810,10 +8132,19 @@ pub unsafe fn sqlite3_wal_autocheckpoint( arg1: *mut sqlite3, arg2: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_wal_autocheckpoint, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( + ((*p_api).wal_autocheckpoint.expect(stringify!( "sqlite3_api contains null pointer for ", "wal_autocheckpoint", " function" @@ -7824,10 +8155,19 @@ pub unsafe fn sqlite3_wal_checkpoint( arg1: *mut sqlite3, arg2: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_wal_checkpoint, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).wal_checkpoint.expect(stringify!( + ((*p_api).wal_checkpoint.expect(stringify!( "sqlite3_api contains null pointer for ", "wal_checkpoint", " function" @@ -7846,10 +8186,19 @@ pub unsafe fn sqlite3_wal_hook( >, arg3: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_wal_hook, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).wal_hook.expect(stringify!( + ((*p_api).wal_hook.expect(stringify!( "sqlite3_api contains null pointer for ", "wal_hook", " function" diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index 68cd7151b..d07c14a59 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -655,18 +655,49 @@ mod bindings { .header(header.clone()) .parse_callbacks(Box::new(SqliteTypeChooser)) .rustfmt_bindings(true); - + #[cfg(feature = "loadable_extension")] + // Create parallel bindgen Builder for generating bindings with comments + // Ideally we would just have one builder until the very end and we could + // just clone it and add `generate_comments(true)` on one of them but + // unfortunately rust-bindgen does not implement Clone on the Builder + // type. See issue: https://github.com/rust-lang/rust-bindgen/issues/2132 + let mut bindings_with_comments = bindgen::builder() + .trust_clang_mangling(false) + .header(header.clone()) + .parse_callbacks(Box::new(SqliteTypeChooser)) + .rustfmt_bindings(true); + if cfg!(any(feature = "sqlcipher", feature = "bundled-sqlcipher")) { bindings = bindings.clang_arg("-DSQLITE_HAS_CODEC"); + // Remove once bindgen can clone: https://github.com/rust-lang/rust-bindgen/issues/2132 + #[cfg(feature = "loadable_extension")] + { + bindings_with_comments = bindings_with_comments.clang_arg("-DSQLITE_HAS_CODEC"); + } } if cfg!(feature = "unlock_notify") { bindings = bindings.clang_arg("-DSQLITE_ENABLE_UNLOCK_NOTIFY"); + // Remove once bindgen can clone: https://github.com/rust-lang/rust-bindgen/issues/2132 + #[cfg(feature = "loadable_extension")] + { + bindings_with_comments = bindings_with_comments.clang_arg("-DSQLITE_ENABLE_UNLOCK_NOTIFY"); + } } if cfg!(feature = "preupdate_hook") { bindings = bindings.clang_arg("-DSQLITE_ENABLE_PREUPDATE_HOOK"); + // Remove once bindgen can clone: https://github.com/rust-lang/rust-bindgen/issues/2132 + #[cfg(feature = "loadable_extension")] + { + bindings_with_comments = bindings_with_comments.clang_arg("-DSQLITE_ENABLE_PREUPDATE_HOOK"); + } } if cfg!(feature = "session") { bindings = bindings.clang_arg("-DSQLITE_ENABLE_SESSION"); + // Remove once bindgen can clone: https://github.com/rust-lang/rust-bindgen/issues/2132 + #[cfg(feature = "loadable_extension")] + { + bindings_with_comments = bindings_with_comments.clang_arg("-DSQLITE_ENABLE_SESSION"); + } } if win_target() && cfg!(feature = "winsqlite3") { bindings = bindings @@ -697,6 +728,38 @@ mod bindings { .blocklist_function("__security_init_cookie") .blocklist_function("__report_gsfailure") .blocklist_function("__va_start"); + // Remove once bindgen can clone: https://github.com/rust-lang/rust-bindgen/issues/2132 + #[cfg(feature = "loadable_extension")] + { + bindings_with_comments = bindings_with_comments + .clang_arg("-DBINDGEN_USE_WINSQLITE3") + .blocklist_item("NTDDI_.+") + .blocklist_item("WINAPI_FAMILY.*") + .blocklist_item("_WIN32_.+") + .blocklist_item("_VCRT_COMPILER_PREPROCESSOR") + .blocklist_item("_SAL_VERSION") + .blocklist_item("__SAL_H_VERSION") + .blocklist_item("_USE_DECLSPECS_FOR_SAL") + .blocklist_item("_USE_ATTRIBUTES_FOR_SAL") + .blocklist_item("_CRT_PACKING") + .blocklist_item("_HAS_EXCEPTIONS") + .blocklist_item("_STL_LANG") + .blocklist_item("_HAS_CXX17") + .blocklist_item("_HAS_CXX20") + .blocklist_item("_HAS_NODISCARD") + .blocklist_item("WDK_NTDDI_VERSION") + .blocklist_item("OSVERSION_MASK") + .blocklist_item("SPVERSION_MASK") + .blocklist_item("SUBVERSION_MASK") + .blocklist_item("WINVER") + .blocklist_item("__security_cookie") + .blocklist_type("size_t") + .blocklist_type("__vcrt_bool") + .blocklist_type("wchar_t") + .blocklist_function("__security_init_cookie") + .blocklist_function("__report_gsfailure") + .blocklist_function("__va_start"); + } } // When cross compiling unless effort is taken to fix the issue, bindgen @@ -723,7 +786,12 @@ mod bindings { if generating_bundled_bindings() || is_cross_compiling { // get rid of blocklisted functions that use va_list for fn_name in blocklist_va_list_functions { - bindings = bindings.blocklist_function(fn_name) + bindings = bindings.blocklist_function(fn_name); + // Remove once bindgen can clone: https://github.com/rust-lang/rust-bindgen/issues/2132 + #[cfg(feature = "loadable_extension")] + { + bindings_with_comments = bindings_with_comments.blocklist_function(fn_name); + } } // Get rid of va_list bindings = bindings @@ -731,41 +799,74 @@ mod bindings { .blocklist_type("__builtin_va_list") .blocklist_type("__gnuc_va_list") .blocklist_item("__GNUC_VA_LIST"); + // Remove once bindgen can clone: https://github.com/rust-lang/rust-bindgen/issues/2132 + #[cfg(feature = "loadable_extension")] + { + bindings_with_comments = bindings_with_comments + .blocklist_type("va_list") + .blocklist_type("__builtin_va_list") + .blocklist_type("__gnuc_va_list") + .blocklist_item("__GNUC_VA_LIST"); + } // handle __va_list_tag specially as it is referenced from sqlite3_api_routines // so if it is blocklisted, those references will be broken for loadable extensions. #[cfg(not(feature = "loadable_extension"))] { bindings = bindings.blocklist_type("__va_list_tag"); + // Remove once bindgen can clone: https://github.com/rust-lang/rust-bindgen/issues/2132 + #[cfg(feature = "loadable_extension")] + { + bindings_with_comments = bindings_with_comments.blocklist_type("__va_list_tag"); + } } // when building as a loadable_extension, make __va_list_tag opaque instead of omitting it #[cfg(feature = "loadable_extension")] { bindings = bindings.opaque_type("__va_list_tag"); + // Remove once bindgen can clone: https://github.com/rust-lang/rust-bindgen/issues/2132 + #[cfg(feature = "loadable_extension")] + { + bindings_with_comments = bindings_with_comments.opaque_type("__va_list_tag"); + } } } // rust-bindgen does not handle CPP macros that alias functions, so // when using sqlite3ext.h to support loadable extensions, the macros // that attempt to redefine sqlite3 API routines to be redirected through - // the global sqlite3_api instance of the sqlite3_api_routines structure - // do not result in any code production. + // the static instance of the sqlite3_api_routines structure do not result + // in any code production. // // Before defining wrappers to take their place, we need to blocklist // all sqlite3 API functions since none of their symbols will be // available directly when being loaded as an extension. #[cfg(feature = "loadable_extension")] { - // some api functions do not have an implementation in sqlite3_api_routines - // (for example: sqlite3_config, sqlite3_initialize, sqlite3_interrupt, ...). - // while this isn't a problem for shared libraries (unless we actually try to - // call them, it is better to blocklist them all so that the build will fail - // if an attempt is made to call an extern function that we know won't exist - // and to avoid undefined symbol issues when linking the loadable extension - // rust code with other (e.g. non-rust) code - bindings = bindings.blocklist_function(".*") + bindings = bindings.blocklist_function(".*"); + // Remove once bindgen can clone: https://github.com/rust-lang/rust-bindgen/issues/2132 + #[cfg(feature = "loadable_extension")] + { + bindings_with_comments = bindings_with_comments.blocklist_function(".*"); + } } + // When building a loadable extension, make a copy of the bindgen + // Builder so we can generate identical output with comments after we + // generate the bindings without comments. + // + // Uncomment once bindgen can clone: https://github.com/rust-lang/rust-bindgen/issues/2132 + // #[cfg(feature = "loadable_extension")] + // let mut bindings_with_comments = bindings.clone(); + + #[cfg(feature = "loadable_extension")] + { + bindings_with_comments = bindings_with_comments + .clang_arg("-fparse-all-comments") + .generate_comments(true); + } + + // Generate rust bindings (without comments) bindings .generate() .unwrap_or_else(|_| panic!("could not run bindgen on header {}", header)) @@ -775,20 +876,42 @@ mod bindings { #[allow(unused_mut)] let mut output_string = String::from_utf8(output).expect("bindgen output was not UTF-8?!"); - // Get the list of API functions supported by sqlite3_api_routines, - // set the corresponding sqlite3 api routine to be blocklisted in the - // final bindgen run, and add wrappers for each of the API functions to - // dispatch the API call through a sqlite3_api global, which is defined - // outside the generated bindings in lib.rs, either as a built-in static - // or an extern symbol in the case of loadable_extension_embedded (i.e. - // when the rust code will be a part of an extension but not implement - // the extension entrypoint itself). #[cfg(feature = "loadable_extension")] { + // When building a loadable extension, we need doc comments to be + // included in the bindings we process to determine minimum version + // requirements for each API function (i.e. those documented in + // `sqlite3ext.h`) + // + // We could just add comments above, but then they would be included + // in the generated bindings which increases their size by ~4x. + // + // Instead, we run bindgen again to generate another version of + // the bindings that includes comments, use that to generate API + // function wrappers, and then insert those wrappers into the + // non-commented bindings generated above. + let mut output_with_comments = Vec::new(); + bindings_with_comments + .generate() + .unwrap_or_else(|_| panic!("could not run bindgen on header {}", header)) + .write(Box::new(&mut output_with_comments)) + .expect("could not write output of bindgen with comments"); + let output_with_comments_string = String::from_utf8(output_with_comments).expect("bindgen output with comments was not UTF-8?!"); + + // Get the list of API functions supported by sqlite3_api_routines, + // and add wrappers for each of the API functions to dispatch the API + // call through the loadable_extension_sqlite3_api(), which is defined + // in the crate outside the generated bindings. + // + // While parsing the bindings, we check for comments (in the form of doc + // attributes) that contain sqlite3 version strings to generate runtime + // checks for minimum version to prevent accessing elements beyond the + // end of the sqlite3_api_routines struct when loaded into an older + // sqlite. let api_routines_struct_name = "sqlite3_api_routines".to_owned(); let api_routines_struct = - match get_struct_by_name(&output_string, &api_routines_struct_name) { + match get_struct_by_name(&output_with_comments_string, &api_routines_struct_name) { Some(s) => s, None => { panic!( @@ -801,14 +924,33 @@ mod bindings { output_string.push_str( r#" -// sqlite3_api is defined in lib.rs as either a static or an extern when compiled as a loadable_extension -use crate::sqlite3_api; +// The `loadable_extension_sqlite3_api` function is defined when compiled as a +// loadable_extension. It is used to safely access the static `SQLITE3_API` +// reference that is populated by a call to either`loadable_extension_init` +// or `loadable_extension_embedded_init` +use crate::loadable_extension_sqlite3_api; -// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from libsqlite3-sys/build.rs - not by rust-bindgen) "#, ); + // compile a regex to match sqlite3 version strings that annotate + // fields in the sqlite3_api_routines struct as comments in + // the sqlite3ext.h sqlite header file + let version_re = regex::Regex::new(r"[^0-9](?P3[.][0-9]+[.][0-9]+)[^0-9]").expect("failed to compile regex"); + + // prior to any version comments, we don't enable any version checks + // the earliest version mentioned is 3.3.13, and it appears from the + // comments that nearly all of the earlier fields in + // `sqlite3_api_routines` existed in the earliest version, with the + // possible exception of `sqlite3_overload_function` which is + // annotated with the comment `Added ???` + // + // I have added a special case for `sqlite3_overload_function` + // to hard-code the version requirement for it to 3.3.13, which is + // the fail-safe way of handling that ambiguity. + let mut require_sqlite3_version = None; // create wrapper for each field in api routines struct for field in &api_routines_struct.fields { let ident = match &field.ident { @@ -818,6 +960,39 @@ use crate::sqlite3_api; } }; let field_type = &field.ty; + for attr in &field.attrs { + match attr.path.get_ident() { + Some(ident) => { + if ident == "doc" { + for t in attr.tokens.clone().into_iter() { + if let proc_macro2::TokenTree::Literal(l) = t { + let literal_comments = l.to_string(); + if let Some(captures) = version_re.captures(&literal_comments) { + if let Some(sqlite3_version_match) = captures.name("version") { + let sqlite3_version = sqlite3_version_match.as_str().to_string(); + match require_sqlite3_version { + None => { + require_sqlite3_version = Some(sqlite3_version); + } + Some(require_sqlite3_version_str) => { + if version_compare::compare_to(&sqlite3_version, &require_sqlite3_version_str, version_compare::Cmp::Lt).expect("failed to compare version strings") { + panic!("Unexpectedly found sqlite3 version requirement in sqlite3ext.h that is lower than the version required for the previous field in sqlite3_api_routines (found '{}' after '{}')", &sqlite3_version, &require_sqlite3_version_str); + } else { + require_sqlite3_version = Some(sqlite3_version); + } + } + } + } else { + panic!("Regex matched but was missing version capture group"); + } + } + } + } + } + } + None => {} + } + } // construct global sqlite api function identifier from field identifier let api_fn_name = format!("sqlite3_{}", ident); @@ -832,7 +1007,14 @@ use crate::sqlite3_api; } // generate wrapper function and push it to output string - let wrapper = generate_wrapper(ident, field_type, &api_fn_name); + let require_sqlite3_version_with_overrides = if &api_fn_name == "sqlite3_overload_function" { + // override the version requirement for sqlite3_overload_function since it is commented + // with `Added ???` in sqlite3ext.h` + Some("3.3.13") + } else { + require_sqlite3_version.as_deref() + }; + let wrapper = generate_wrapper(ident, field_type, &api_fn_name, require_sqlite3_version_with_overrides); output_string.push_str(&wrapper); } @@ -983,6 +1165,7 @@ use crate::sqlite3_api; field_ident: &syn::Ident, syn_type: &syn::Type, api_fn_name: &str, + require_sqlite3_version: Option<&str>, ) -> String { use quote::quote; use std::collections::BTreeMap; @@ -1069,13 +1252,54 @@ use crate::sqlite3_api; }) .collect(); + // Generate api version check to check the require_sqlite3_version_number + // against the SQLITE_VERSION_NUMBER style integer version returned by a + // sqlite3_libversion_number() call in order to protect api calls from + // being made when the sqlite version the extension is loaded into does + // not support them. + // For more information, refer to sqlite docs: https://sqlite.org/c3ref/c_source_id.html + let api_version_check_tokens = match require_sqlite3_version { + Some(version) => { + let require_sqlite3_version = version_compare::Version::from(version).expect("failed to parse required sqlite3 version as Version"); + let require_sqlite3_version_parts = require_sqlite3_version.parts(); + if require_sqlite3_version_parts.len() != 3 { + panic!("sqlite3 version '{}' does not have exactly three parts", version); + } + let major = match require_sqlite3_version_parts[0] { + version_compare::Part::Number(major) => major, + _ => { + panic!("non-numeric major part found in sqlite3 version requirement '{}'", require_sqlite3_version_parts[0]); + } + }; + let minor = match require_sqlite3_version_parts[1] { + version_compare::Part::Number(minor) => minor, + _ => { + panic!("non-numeric minor part found in sqlite3 version requirement '{}'", require_sqlite3_version_parts[1]); + } + }; + let patch = match require_sqlite3_version_parts[2] { + version_compare::Part::Number(patch) => patch, + _ => { + panic!("non-numeric patch part found in sqlite3 version requirement '{}'", require_sqlite3_version_parts[2]); + } + }; + let require_sqlite3_version_number = 1_000_000 * major + 1_000 * minor + patch; + quote! { + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < #require_sqlite3_version_number { + panic!(stringify!("sqlite3 version is {} but version {} is required for the ", #api_fn_ident, " function"), sqlite3_version_number, #require_sqlite3_version_number); + } + } + } + None => quote! {}, + }; + // generate wrapper and return it as a string let wrapper_tokens = quote! { pub unsafe fn #api_fn_ident(#api_fn_inputs) #api_fn_output { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).#field_ident + let p_api = loadable_extension_sqlite3_api(); + #api_version_check_tokens + ((*p_api).#field_ident .expect(stringify!("sqlite3_api contains null pointer for ", #field_name, " function")))( #(#api_fn_input_idents),* ) diff --git a/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs b/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs index 32bd9484a..c7e598056 100644 --- a/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs +++ b/libsqlite3-sys/sqlite3/bindgen_bundled_version-ext.rs @@ -1,9 +1,9 @@ -/* automatically generated by rust-bindgen 0.57.0 */ +/* automatically generated by rust-bindgen 0.59.2 */ -pub const SQLITE_VERSION: &'static [u8; 7usize] = b"3.34.0\0"; -pub const SQLITE_VERSION_NUMBER: i32 = 3034000; -pub const SQLITE_SOURCE_ID: &'static [u8; 85usize] = - b"2020-12-01 16:14:00 a26b6597e3ae272231b96f9982c3bcc17ddec2f2b6eb4df06a224b91089fed5b\0"; +pub const SQLITE_VERSION: &[u8; 7usize] = b"3.37.0\0"; +pub const SQLITE_VERSION_NUMBER: i32 = 3037000; +pub const SQLITE_SOURCE_ID: &[u8; 85usize] = + b"2021-11-27 14:13:22 bd41822c7424d393a30e92ff6cb254d25c26769889c1499a18a0b9339f5d6c8a\0"; pub const SQLITE_OK: i32 = 0; pub const SQLITE_ERROR: i32 = 1; pub const SQLITE_INTERNAL: i32 = 2; @@ -103,6 +103,7 @@ pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067; pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323; pub const SQLITE_CONSTRAINT_ROWID: i32 = 2579; pub const SQLITE_CONSTRAINT_PINNED: i32 = 2835; +pub const SQLITE_CONSTRAINT_DATATYPE: i32 = 3091; pub const SQLITE_NOTICE_RECOVER_WAL: i32 = 283; pub const SQLITE_NOTICE_RECOVER_ROLLBACK: i32 = 539; pub const SQLITE_WARNING_AUTOINDEX: i32 = 284; @@ -130,6 +131,7 @@ pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072; pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144; pub const SQLITE_OPEN_WAL: i32 = 524288; pub const SQLITE_OPEN_NOFOLLOW: i32 = 16777216; +pub const SQLITE_OPEN_EXRESCODE: i32 = 33554432; pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384; pub const SQLITE_IOCAP_ATOMIC: i32 = 1; pub const SQLITE_IOCAP_ATOMIC512: i32 = 2; @@ -192,6 +194,8 @@ pub const SQLITE_FCNTL_SIZE_LIMIT: i32 = 36; pub const SQLITE_FCNTL_CKPT_DONE: i32 = 37; pub const SQLITE_FCNTL_RESERVE_BYTES: i32 = 38; pub const SQLITE_FCNTL_CKPT_START: i32 = 39; +pub const SQLITE_FCNTL_EXTERNAL_READER: i32 = 40; +pub const SQLITE_FCNTL_CKSM_FILE: i32 = 41; pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2; pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3; pub const SQLITE_LAST_ERRNO: i32 = 4; @@ -388,7 +392,9 @@ pub const SQLITE_TESTCTRL_RESULT_INTREAL: i32 = 27; pub const SQLITE_TESTCTRL_PRNG_SEED: i32 = 28; pub const SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS: i32 = 29; pub const SQLITE_TESTCTRL_SEEK_COUNT: i32 = 30; -pub const SQLITE_TESTCTRL_LAST: i32 = 30; +pub const SQLITE_TESTCTRL_TRACEFLAGS: i32 = 31; +pub const SQLITE_TESTCTRL_TUNE: i32 = 32; +pub const SQLITE_TESTCTRL_LAST: i32 = 32; pub const SQLITE_STATUS_MEMORY_USED: i32 = 0; pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1; pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2; @@ -2711,7 +2717,7 @@ pub struct sqlite3_backup { _unused: [u8; 0], } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Debug, Copy, Clone)] pub struct sqlite3_snapshot { pub hidden: [::std::os::raw::c_uchar; 48usize], } @@ -5014,12 +5020,31 @@ pub struct sqlite3_api_routines { arg2: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int, >, + pub changes64: ::std::option::Option sqlite3_int64>, + pub total_changes64: + ::std::option::Option sqlite3_int64>, + pub autovacuum_pages: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_uint, + arg4: ::std::os::raw::c_uint, + arg5: ::std::os::raw::c_uint, + ) -> ::std::os::raw::c_uint, + >, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, + ) -> ::std::os::raw::c_int, + >, } #[test] fn bindgen_test_layout_sqlite3_api_routines() { assert_eq!( ::std::mem::size_of::(), - 2024usize, + 2048usize, concat!("Size of: ", stringify!(sqlite3_api_routines)) ); assert_eq!( @@ -7900,6 +7925,40 @@ fn bindgen_test_layout_sqlite3_api_routines() { stringify!(txn_state) ) ); + assert_eq!( + unsafe { &(*(::std::ptr::null::())).changes64 as *const _ as usize }, + 2024usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(changes64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).total_changes64 as *const _ as usize + }, + 2032usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(total_changes64) + ) + ); + assert_eq!( + unsafe { + &(*(::std::ptr::null::())).autovacuum_pages as *const _ as usize + }, + 2040usize, + concat!( + "Offset of field: ", + stringify!(sqlite3_api_routines), + "::", + stringify!(autovacuum_pages) + ) + ); } pub type sqlite3_loadext_entry = ::std::option::Option< unsafe extern "C" fn( @@ -7928,19 +7987,20 @@ fn bindgen_test_layout___va_list_tag() { ); } -// sqlite3_api is defined in lib.rs as either a static or an extern when compiled as a loadable_extension -use crate::sqlite3_api; +// The `loadable_extension_sqlite3_api` function is defined when compiled as a +// loadable_extension. It is used to safely access the static `SQLITE3_API` +// reference that is populated by a call to either`loadable_extension_init` +// or `loadable_extension_embedded_init` +use crate::loadable_extension_sqlite3_api; -// sqlite3 API wrappers to support loadable extensions (Note: these were generated from build.rs - not by rust-bindgen) +// sqlite3 API wrappers to support loadable extensions (Note: these were generated from libsqlite3-sys/build.rs - not by rust-bindgen) pub unsafe fn sqlite3_aggregate_context( arg1: *mut sqlite3_context, nBytes: ::std::os::raw::c_int, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_context.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).aggregate_context.expect(stringify!( "sqlite3_api contains null pointer for ", "aggregate_context", " function" @@ -7948,10 +8008,8 @@ pub unsafe fn sqlite3_aggregate_context( } pub unsafe fn sqlite3_aggregate_count(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).aggregate_count.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).aggregate_count.expect(stringify!( "sqlite3_api contains null pointer for ", "aggregate_count", " function" @@ -7965,10 +8023,8 @@ pub unsafe fn sqlite3_bind_blob( n: ::std::os::raw::c_int, arg4: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_blob.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_blob.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_blob", " function" @@ -7980,10 +8036,8 @@ pub unsafe fn sqlite3_bind_double( arg2: ::std::os::raw::c_int, arg3: f64, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_double.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_double.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_double", " function" @@ -7995,10 +8049,8 @@ pub unsafe fn sqlite3_bind_int( arg2: ::std::os::raw::c_int, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_int.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_int", " function" @@ -8010,10 +8062,8 @@ pub unsafe fn sqlite3_bind_int64( arg2: ::std::os::raw::c_int, arg3: sqlite_int64, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_int64.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_int64.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_int64", " function" @@ -8024,10 +8074,8 @@ pub unsafe fn sqlite3_bind_null( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_null.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_null.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_null", " function" @@ -8035,10 +8083,8 @@ pub unsafe fn sqlite3_bind_null( } pub unsafe fn sqlite3_bind_parameter_count(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_count.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_parameter_count.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_parameter_count", " function" @@ -8049,10 +8095,8 @@ pub unsafe fn sqlite3_bind_parameter_index( arg1: *mut sqlite3_stmt, zName: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_index.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_parameter_index.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_parameter_index", " function" @@ -8063,10 +8107,8 @@ pub unsafe fn sqlite3_bind_parameter_name( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_parameter_name.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_parameter_name.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_parameter_name", " function" @@ -8080,10 +8122,8 @@ pub unsafe fn sqlite3_bind_text( n: ::std::os::raw::c_int, arg4: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_text.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_text", " function" @@ -8097,10 +8137,8 @@ pub unsafe fn sqlite3_bind_text16( arg4: ::std::os::raw::c_int, arg5: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_text16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_text16.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_text16", " function" @@ -8112,10 +8150,8 @@ pub unsafe fn sqlite3_bind_value( arg2: ::std::os::raw::c_int, arg3: *const sqlite3_value, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).bind_value.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).bind_value.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_value", " function" @@ -8132,10 +8168,8 @@ pub unsafe fn sqlite3_busy_handler( >, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_handler.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).busy_handler.expect(stringify!( "sqlite3_api contains null pointer for ", "busy_handler", " function" @@ -8146,10 +8180,8 @@ pub unsafe fn sqlite3_busy_timeout( arg1: *mut sqlite3, ms: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).busy_timeout.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).busy_timeout.expect(stringify!( "sqlite3_api contains null pointer for ", "busy_timeout", " function" @@ -8157,10 +8189,8 @@ pub unsafe fn sqlite3_busy_timeout( } pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).changes.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).changes.expect(stringify!( "sqlite3_api contains null pointer for ", "changes", " function" @@ -8168,10 +8198,8 @@ pub unsafe fn sqlite3_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { } pub unsafe fn sqlite3_close(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).close.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).close.expect(stringify!( "sqlite3_api contains null pointer for ", "close", " function" @@ -8190,10 +8218,8 @@ pub unsafe fn sqlite3_collation_needed( ), >, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).collation_needed.expect(stringify!( "sqlite3_api contains null pointer for ", "collation_needed", " function" @@ -8212,10 +8238,8 @@ pub unsafe fn sqlite3_collation_needed16( ), >, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).collation_needed16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).collation_needed16.expect(stringify!( "sqlite3_api contains null pointer for ", "collation_needed16", " function" @@ -8226,10 +8250,8 @@ pub unsafe fn sqlite3_column_blob( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_blob.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_blob.expect(stringify!( "sqlite3_api contains null pointer for ", "column_blob", " function" @@ -8240,10 +8262,8 @@ pub unsafe fn sqlite3_column_bytes( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_bytes.expect(stringify!( "sqlite3_api contains null pointer for ", "column_bytes", " function" @@ -8254,10 +8274,8 @@ pub unsafe fn sqlite3_column_bytes16( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_bytes16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_bytes16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_bytes16", " function" @@ -8265,10 +8283,8 @@ pub unsafe fn sqlite3_column_bytes16( } pub unsafe fn sqlite3_column_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_count.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_count.expect(stringify!( "sqlite3_api contains null pointer for ", "column_count", " function" @@ -8279,10 +8295,8 @@ pub unsafe fn sqlite3_column_database_name( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_database_name.expect(stringify!( "sqlite3_api contains null pointer for ", "column_database_name", " function" @@ -8293,10 +8307,8 @@ pub unsafe fn sqlite3_column_database_name16( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_database_name16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_database_name16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_database_name16", " function" @@ -8307,10 +8319,8 @@ pub unsafe fn sqlite3_column_decltype( arg1: *mut sqlite3_stmt, i: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_decltype.expect(stringify!( "sqlite3_api contains null pointer for ", "column_decltype", " function" @@ -8321,10 +8331,8 @@ pub unsafe fn sqlite3_column_decltype16( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_decltype16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_decltype16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_decltype16", " function" @@ -8332,10 +8340,8 @@ pub unsafe fn sqlite3_column_decltype16( } pub unsafe fn sqlite3_column_double(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_double.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_double.expect(stringify!( "sqlite3_api contains null pointer for ", "column_double", " function" @@ -8346,10 +8352,8 @@ pub unsafe fn sqlite3_column_int( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_int.expect(stringify!( "sqlite3_api contains null pointer for ", "column_int", " function" @@ -8360,10 +8364,8 @@ pub unsafe fn sqlite3_column_int64( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_int64.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_int64.expect(stringify!( "sqlite3_api contains null pointer for ", "column_int64", " function" @@ -8374,10 +8376,8 @@ pub unsafe fn sqlite3_column_name( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_name.expect(stringify!( "sqlite3_api contains null pointer for ", "column_name", " function" @@ -8388,10 +8388,8 @@ pub unsafe fn sqlite3_column_name16( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_name16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_name16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_name16", " function" @@ -8402,10 +8400,8 @@ pub unsafe fn sqlite3_column_origin_name( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_origin_name.expect(stringify!( "sqlite3_api contains null pointer for ", "column_origin_name", " function" @@ -8416,10 +8412,8 @@ pub unsafe fn sqlite3_column_origin_name16( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_origin_name16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_origin_name16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_origin_name16", " function" @@ -8430,10 +8424,8 @@ pub unsafe fn sqlite3_column_table_name( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_table_name.expect(stringify!( "sqlite3_api contains null pointer for ", "column_table_name", " function" @@ -8444,10 +8436,8 @@ pub unsafe fn sqlite3_column_table_name16( arg1: *mut sqlite3_stmt, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_table_name16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_table_name16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_table_name16", " function" @@ -8458,10 +8448,8 @@ pub unsafe fn sqlite3_column_text( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_text.expect(stringify!( "sqlite3_api contains null pointer for ", "column_text", " function" @@ -8472,10 +8460,8 @@ pub unsafe fn sqlite3_column_text16( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_text16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_text16.expect(stringify!( "sqlite3_api contains null pointer for ", "column_text16", " function" @@ -8486,10 +8472,8 @@ pub unsafe fn sqlite3_column_type( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_type.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_type.expect(stringify!( "sqlite3_api contains null pointer for ", "column_type", " function" @@ -8500,10 +8484,8 @@ pub unsafe fn sqlite3_column_value( arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int, ) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).column_value.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).column_value.expect(stringify!( "sqlite3_api contains null pointer for ", "column_value", " function" @@ -8517,10 +8499,8 @@ pub unsafe fn sqlite3_commit_hook( >, arg3: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).commit_hook.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).commit_hook.expect(stringify!( "sqlite3_api contains null pointer for ", "commit_hook", " function" @@ -8528,10 +8508,8 @@ pub unsafe fn sqlite3_commit_hook( } pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).complete.expect(stringify!( "sqlite3_api contains null pointer for ", "complete", " function" @@ -8539,10 +8517,8 @@ pub unsafe fn sqlite3_complete(sql: *const ::std::os::raw::c_char) -> ::std::os: } pub unsafe fn sqlite3_complete16(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).complete16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).complete16.expect(stringify!( "sqlite3_api contains null pointer for ", "complete16", " function" @@ -8564,10 +8540,8 @@ pub unsafe fn sqlite3_create_collation( ) -> ::std::os::raw::c_int, >, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).create_collation.expect(stringify!( "sqlite3_api contains null pointer for ", "create_collation", " function" @@ -8589,10 +8563,8 @@ pub unsafe fn sqlite3_create_collation16( ) -> ::std::os::raw::c_int, >, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_collation16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).create_collation16.expect(stringify!( "sqlite3_api contains null pointer for ", "create_collation16", " function" @@ -8621,10 +8593,8 @@ pub unsafe fn sqlite3_create_function( >, xFinal: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).create_function.expect(stringify!( "sqlite3_api contains null pointer for ", "create_function", " function" @@ -8653,10 +8623,8 @@ pub unsafe fn sqlite3_create_function16( >, xFinal: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_function16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).create_function16.expect(stringify!( "sqlite3_api contains null pointer for ", "create_function16", " function" @@ -8669,10 +8637,8 @@ pub unsafe fn sqlite3_create_module( arg3: *const sqlite3_module, arg4: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).create_module.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).create_module.expect(stringify!( "sqlite3_api contains null pointer for ", "create_module", " function" @@ -8680,10 +8646,8 @@ pub unsafe fn sqlite3_create_module( } pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).data_count.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).data_count.expect(stringify!( "sqlite3_api contains null pointer for ", "data_count", " function" @@ -8691,10 +8655,8 @@ pub unsafe fn sqlite3_data_count(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_ } pub unsafe fn sqlite3_db_handle(arg1: *mut sqlite3_stmt) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).db_handle.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).db_handle.expect(stringify!( "sqlite3_api contains null pointer for ", "db_handle", " function" @@ -8705,10 +8667,8 @@ pub unsafe fn sqlite3_declare_vtab( arg1: *mut sqlite3, arg2: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).declare_vtab.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).declare_vtab.expect(stringify!( "sqlite3_api contains null pointer for ", "declare_vtab", " function" @@ -8716,10 +8676,8 @@ pub unsafe fn sqlite3_declare_vtab( } pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).enable_shared_cache.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).enable_shared_cache.expect(stringify!( "sqlite3_api contains null pointer for ", "enable_shared_cache", " function" @@ -8727,10 +8685,8 @@ pub unsafe fn sqlite3_enable_shared_cache(arg1: ::std::os::raw::c_int) -> ::std: } pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errcode.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).errcode.expect(stringify!( "sqlite3_api contains null pointer for ", "errcode", " function" @@ -8738,10 +8694,8 @@ pub unsafe fn sqlite3_errcode(db: *mut sqlite3) -> ::std::os::raw::c_int { } pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).errmsg.expect(stringify!( "sqlite3_api contains null pointer for ", "errmsg", " function" @@ -8749,10 +8703,8 @@ pub unsafe fn sqlite3_errmsg(arg1: *mut sqlite3) -> *const ::std::os::raw::c_cha } pub unsafe fn sqlite3_errmsg16(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).errmsg16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).errmsg16.expect(stringify!( "sqlite3_api contains null pointer for ", "errmsg16", " function" @@ -8766,10 +8718,8 @@ pub unsafe fn sqlite3_exec( arg4: *mut ::std::os::raw::c_void, arg5: *mut *mut ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).exec.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).exec.expect(stringify!( "sqlite3_api contains null pointer for ", "exec", " function" @@ -8777,10 +8727,8 @@ pub unsafe fn sqlite3_exec( } pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).expired.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).expired.expect(stringify!( "sqlite3_api contains null pointer for ", "expired", " function" @@ -8788,10 +8736,8 @@ pub unsafe fn sqlite3_expired(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int } pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).finalize.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).finalize.expect(stringify!( "sqlite3_api contains null pointer for ", "finalize", " function" @@ -8799,10 +8745,8 @@ pub unsafe fn sqlite3_finalize(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_in } pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).free.expect(stringify!( "sqlite3_api contains null pointer for ", "free", " function" @@ -8810,10 +8754,8 @@ pub unsafe fn sqlite3_free(arg1: *mut ::std::os::raw::c_void) { } pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).free_table.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).free_table.expect(stringify!( "sqlite3_api contains null pointer for ", "free_table", " function" @@ -8821,10 +8763,8 @@ pub unsafe fn sqlite3_free_table(result: *mut *mut ::std::os::raw::c_char) { } pub unsafe fn sqlite3_get_autocommit(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_autocommit.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).get_autocommit.expect(stringify!( "sqlite3_api contains null pointer for ", "get_autocommit", " function" @@ -8835,10 +8775,8 @@ pub unsafe fn sqlite3_get_auxdata( arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_auxdata.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).get_auxdata.expect(stringify!( "sqlite3_api contains null pointer for ", "get_auxdata", " function" @@ -8853,10 +8791,8 @@ pub unsafe fn sqlite3_get_table( arg5: *mut ::std::os::raw::c_int, arg6: *mut *mut ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).get_table.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).get_table.expect(stringify!( "sqlite3_api contains null pointer for ", "get_table", " function" @@ -8864,10 +8800,8 @@ pub unsafe fn sqlite3_get_table( } pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).global_recover.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).global_recover.expect(stringify!( "sqlite3_api contains null pointer for ", "global_recover", " function" @@ -8875,10 +8809,8 @@ pub unsafe fn sqlite3_global_recover() -> ::std::os::raw::c_int { } pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).interruptx.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).interruptx.expect(stringify!( "sqlite3_api contains null pointer for ", "interruptx", " function" @@ -8886,10 +8818,8 @@ pub unsafe fn sqlite3_interruptx(arg1: *mut sqlite3) { } pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).last_insert_rowid.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).last_insert_rowid.expect(stringify!( "sqlite3_api contains null pointer for ", "last_insert_rowid", " function" @@ -8897,10 +8827,8 @@ pub unsafe fn sqlite3_last_insert_rowid(arg1: *mut sqlite3) -> sqlite_int64 { } pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).libversion.expect(stringify!( "sqlite3_api contains null pointer for ", "libversion", " function" @@ -8908,10 +8836,8 @@ pub unsafe fn sqlite3_libversion() -> *const ::std::os::raw::c_char { } pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).libversion_number.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).libversion_number.expect(stringify!( "sqlite3_api contains null pointer for ", "libversion_number", " function" @@ -8919,10 +8845,8 @@ pub unsafe fn sqlite3_libversion_number() -> ::std::os::raw::c_int { } pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).malloc.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).malloc.expect(stringify!( "sqlite3_api contains null pointer for ", "malloc", " function" @@ -8930,10 +8854,8 @@ pub unsafe fn sqlite3_malloc(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw } pub unsafe fn sqlite3_mprintf(arg1: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).mprintf.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).mprintf.expect(stringify!( "sqlite3_api contains null pointer for ", "mprintf", " function" @@ -8944,10 +8866,8 @@ pub unsafe fn sqlite3_open( arg1: *const ::std::os::raw::c_char, arg2: *mut *mut sqlite3, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).open.expect(stringify!( "sqlite3_api contains null pointer for ", "open", " function" @@ -8958,10 +8878,8 @@ pub unsafe fn sqlite3_open16( arg1: *const ::std::os::raw::c_void, arg2: *mut *mut sqlite3, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).open16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).open16.expect(stringify!( "sqlite3_api contains null pointer for ", "open16", " function" @@ -8975,10 +8893,8 @@ pub unsafe fn sqlite3_prepare( arg4: *mut *mut sqlite3_stmt, arg5: *mut *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).prepare.expect(stringify!( "sqlite3_api contains null pointer for ", "prepare", " function" @@ -8992,10 +8908,8 @@ pub unsafe fn sqlite3_prepare16( arg4: *mut *mut sqlite3_stmt, arg5: *mut *const ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).prepare16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).prepare16.expect(stringify!( "sqlite3_api contains null pointer for ", "prepare16", " function" @@ -9013,10 +8927,8 @@ pub unsafe fn sqlite3_profile( >, arg3: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).profile.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).profile.expect(stringify!( "sqlite3_api contains null pointer for ", "profile", " function" @@ -9031,10 +8943,8 @@ pub unsafe fn sqlite3_progress_handler( >, arg4: *mut ::std::os::raw::c_void, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).progress_handler.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).progress_handler.expect(stringify!( "sqlite3_api contains null pointer for ", "progress_handler", " function" @@ -9045,10 +8955,8 @@ pub unsafe fn sqlite3_realloc( arg1: *mut ::std::os::raw::c_void, arg2: ::std::os::raw::c_int, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).realloc.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).realloc.expect(stringify!( "sqlite3_api contains null pointer for ", "realloc", " function" @@ -9056,10 +8964,8 @@ pub unsafe fn sqlite3_realloc( } pub unsafe fn sqlite3_reset(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).reset.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).reset.expect(stringify!( "sqlite3_api contains null pointer for ", "reset", " function" @@ -9072,10 +8978,8 @@ pub unsafe fn sqlite3_result_blob( arg3: ::std::os::raw::c_int, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_blob.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_blob.expect(stringify!( "sqlite3_api contains null pointer for ", "result_blob", " function" @@ -9083,10 +8987,8 @@ pub unsafe fn sqlite3_result_blob( } pub unsafe fn sqlite3_result_double(arg1: *mut sqlite3_context, arg2: f64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_double.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_double.expect(stringify!( "sqlite3_api contains null pointer for ", "result_double", " function" @@ -9098,10 +9000,8 @@ pub unsafe fn sqlite3_result_error( arg2: *const ::std::os::raw::c_char, arg3: ::std::os::raw::c_int, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_error.expect(stringify!( "sqlite3_api contains null pointer for ", "result_error", " function" @@ -9113,10 +9013,8 @@ pub unsafe fn sqlite3_result_error16( arg2: *const ::std::os::raw::c_void, arg3: ::std::os::raw::c_int, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_error16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_error16.expect(stringify!( "sqlite3_api contains null pointer for ", "result_error16", " function" @@ -9124,10 +9022,8 @@ pub unsafe fn sqlite3_result_error16( } pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_int.expect(stringify!( "sqlite3_api contains null pointer for ", "result_int", " function" @@ -9135,10 +9031,8 @@ pub unsafe fn sqlite3_result_int(arg1: *mut sqlite3_context, arg2: ::std::os::ra } pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_int64.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_int64.expect(stringify!( "sqlite3_api contains null pointer for ", "result_int64", " function" @@ -9146,10 +9040,8 @@ pub unsafe fn sqlite3_result_int64(arg1: *mut sqlite3_context, arg2: sqlite_int6 } pub unsafe fn sqlite3_result_null(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_null.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_null.expect(stringify!( "sqlite3_api contains null pointer for ", "result_null", " function" @@ -9162,10 +9054,8 @@ pub unsafe fn sqlite3_result_text( arg3: ::std::os::raw::c_int, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_text.expect(stringify!( "sqlite3_api contains null pointer for ", "result_text", " function" @@ -9178,10 +9068,8 @@ pub unsafe fn sqlite3_result_text16( arg3: ::std::os::raw::c_int, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_text16.expect(stringify!( "sqlite3_api contains null pointer for ", "result_text16", " function" @@ -9194,10 +9082,8 @@ pub unsafe fn sqlite3_result_text16be( arg3: ::std::os::raw::c_int, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16be.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_text16be.expect(stringify!( "sqlite3_api contains null pointer for ", "result_text16be", " function" @@ -9210,10 +9096,8 @@ pub unsafe fn sqlite3_result_text16le( arg3: ::std::os::raw::c_int, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_text16le.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_text16le.expect(stringify!( "sqlite3_api contains null pointer for ", "result_text16le", " function" @@ -9221,10 +9105,8 @@ pub unsafe fn sqlite3_result_text16le( } pub unsafe fn sqlite3_result_value(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).result_value.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).result_value.expect(stringify!( "sqlite3_api contains null pointer for ", "result_value", " function" @@ -9236,10 +9118,8 @@ pub unsafe fn sqlite3_rollback_hook( arg2: ::std::option::Option, arg3: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).rollback_hook.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).rollback_hook.expect(stringify!( "sqlite3_api contains null pointer for ", "rollback_hook", " function" @@ -9260,10 +9140,8 @@ pub unsafe fn sqlite3_set_authorizer( >, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_authorizer.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).set_authorizer.expect(stringify!( "sqlite3_api contains null pointer for ", "set_authorizer", " function" @@ -9276,10 +9154,8 @@ pub unsafe fn sqlite3_set_auxdata( arg3: *mut ::std::os::raw::c_void, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).set_auxdata.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).set_auxdata.expect(stringify!( "sqlite3_api contains null pointer for ", "set_auxdata", " function" @@ -9291,10 +9167,8 @@ pub unsafe fn sqlite3_xsnprintf( arg2: *mut ::std::os::raw::c_char, arg3: *const ::std::os::raw::c_char, ) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).xsnprintf.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).xsnprintf.expect(stringify!( "sqlite3_api contains null pointer for ", "xsnprintf", " function" @@ -9302,10 +9176,8 @@ pub unsafe fn sqlite3_xsnprintf( } pub unsafe fn sqlite3_step(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).step.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).step.expect(stringify!( "sqlite3_api contains null pointer for ", "step", " function" @@ -9323,10 +9195,8 @@ pub unsafe fn sqlite3_table_column_metadata( arg8: *mut ::std::os::raw::c_int, arg9: *mut ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).table_column_metadata.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).table_column_metadata.expect(stringify!( "sqlite3_api contains null pointer for ", "table_column_metadata", " function" @@ -9334,10 +9204,8 @@ pub unsafe fn sqlite3_table_column_metadata( } pub unsafe fn sqlite3_thread_cleanup() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).thread_cleanup.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).thread_cleanup.expect(stringify!( "sqlite3_api contains null pointer for ", "thread_cleanup", " function" @@ -9345,10 +9213,8 @@ pub unsafe fn sqlite3_thread_cleanup() { } pub unsafe fn sqlite3_total_changes(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).total_changes.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).total_changes.expect(stringify!( "sqlite3_api contains null pointer for ", "total_changes", " function" @@ -9365,10 +9231,8 @@ pub unsafe fn sqlite3_trace( >, arg2: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).trace.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).trace.expect(stringify!( "sqlite3_api contains null pointer for ", "trace", " function" @@ -9379,10 +9243,8 @@ pub unsafe fn sqlite3_transfer_bindings( arg1: *mut sqlite3_stmt, arg2: *mut sqlite3_stmt, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).transfer_bindings.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).transfer_bindings.expect(stringify!( "sqlite3_api contains null pointer for ", "transfer_bindings", " function" @@ -9402,10 +9264,8 @@ pub unsafe fn sqlite3_update_hook( >, arg3: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).update_hook.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).update_hook.expect(stringify!( "sqlite3_api contains null pointer for ", "update_hook", " function" @@ -9413,10 +9273,8 @@ pub unsafe fn sqlite3_update_hook( } pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).user_data.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).user_data.expect(stringify!( "sqlite3_api contains null pointer for ", "user_data", " function" @@ -9424,10 +9282,8 @@ pub unsafe fn sqlite3_user_data(arg1: *mut sqlite3_context) -> *mut ::std::os::r } pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_blob.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_blob.expect(stringify!( "sqlite3_api contains null pointer for ", "value_blob", " function" @@ -9435,10 +9291,8 @@ pub unsafe fn sqlite3_value_blob(arg1: *mut sqlite3_value) -> *const ::std::os:: } pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_bytes.expect(stringify!( "sqlite3_api contains null pointer for ", "value_bytes", " function" @@ -9446,10 +9300,8 @@ pub unsafe fn sqlite3_value_bytes(arg1: *mut sqlite3_value) -> ::std::os::raw::c } pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_bytes16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_bytes16.expect(stringify!( "sqlite3_api contains null pointer for ", "value_bytes16", " function" @@ -9457,10 +9309,8 @@ pub unsafe fn sqlite3_value_bytes16(arg1: *mut sqlite3_value) -> ::std::os::raw: } pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_double.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_double.expect(stringify!( "sqlite3_api contains null pointer for ", "value_double", " function" @@ -9468,10 +9318,8 @@ pub unsafe fn sqlite3_value_double(arg1: *mut sqlite3_value) -> f64 { } pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_int.expect(stringify!( "sqlite3_api contains null pointer for ", "value_int", " function" @@ -9479,10 +9327,8 @@ pub unsafe fn sqlite3_value_int(arg1: *mut sqlite3_value) -> ::std::os::raw::c_i } pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_int64.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_int64.expect(stringify!( "sqlite3_api contains null pointer for ", "value_int64", " function" @@ -9490,10 +9336,8 @@ pub unsafe fn sqlite3_value_int64(arg1: *mut sqlite3_value) -> sqlite_int64 { } pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_numeric_type.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_numeric_type.expect(stringify!( "sqlite3_api contains null pointer for ", "value_numeric_type", " function" @@ -9501,10 +9345,8 @@ pub unsafe fn sqlite3_value_numeric_type(arg1: *mut sqlite3_value) -> ::std::os: } pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_text.expect(stringify!( "sqlite3_api contains null pointer for ", "value_text", " function" @@ -9512,10 +9354,8 @@ pub unsafe fn sqlite3_value_text(arg1: *mut sqlite3_value) -> *const ::std::os:: } pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_text16.expect(stringify!( "sqlite3_api contains null pointer for ", "value_text16", " function" @@ -9523,10 +9363,8 @@ pub unsafe fn sqlite3_value_text16(arg1: *mut sqlite3_value) -> *const ::std::os } pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16be.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_text16be.expect(stringify!( "sqlite3_api contains null pointer for ", "value_text16be", " function" @@ -9534,10 +9372,8 @@ pub unsafe fn sqlite3_value_text16be(arg1: *mut sqlite3_value) -> *const ::std:: } pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_text16le.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_text16le.expect(stringify!( "sqlite3_api contains null pointer for ", "value_text16le", " function" @@ -9545,10 +9381,8 @@ pub unsafe fn sqlite3_value_text16le(arg1: *mut sqlite3_value) -> *const ::std:: } pub unsafe fn sqlite3_value_type(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); - } - ((*sqlite3_api).value_type.expect(stringify!( + let p_api = loadable_extension_sqlite3_api(); + ((*p_api).value_type.expect(stringify!( "sqlite3_api contains null pointer for ", "value_type", " function" @@ -9560,10 +9394,19 @@ pub unsafe fn sqlite3_overload_function( zFuncName: *const ::std::os::raw::c_char, nArg: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3003013i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_overload_function, + " function" + ), + sqlite3_version_number, 3003013i32 + ); } - ((*sqlite3_api).overload_function.expect(stringify!( + ((*p_api).overload_function.expect(stringify!( "sqlite3_api contains null pointer for ", "overload_function", " function" @@ -9577,10 +9420,19 @@ pub unsafe fn sqlite3_prepare_v2( arg4: *mut *mut sqlite3_stmt, arg5: *mut *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3003013i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_prepare_v2, + " function" + ), + sqlite3_version_number, 3003013i32 + ); } - ((*sqlite3_api).prepare_v2.expect(stringify!( + ((*p_api).prepare_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "prepare_v2", " function" @@ -9594,10 +9446,19 @@ pub unsafe fn sqlite3_prepare16_v2( arg4: *mut *mut sqlite3_stmt, arg5: *mut *const ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3003013i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_prepare16_v2, + " function" + ), + sqlite3_version_number, 3003013i32 + ); } - ((*sqlite3_api).prepare16_v2.expect(stringify!( + ((*p_api).prepare16_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "prepare16_v2", " function" @@ -9605,10 +9466,19 @@ pub unsafe fn sqlite3_prepare16_v2( } pub unsafe fn sqlite3_clear_bindings(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3003013i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_clear_bindings, + " function" + ), + sqlite3_version_number, 3003013i32 + ); } - ((*sqlite3_api).clear_bindings.expect(stringify!( + ((*p_api).clear_bindings.expect(stringify!( "sqlite3_api contains null pointer for ", "clear_bindings", " function" @@ -9622,10 +9492,19 @@ pub unsafe fn sqlite3_create_module_v2( arg4: *mut ::std::os::raw::c_void, xDestroy: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3004001i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_create_module_v2, + " function" + ), + sqlite3_version_number, 3004001i32 + ); } - ((*sqlite3_api).create_module_v2.expect(stringify!( + ((*p_api).create_module_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "create_module_v2", " function" @@ -9637,10 +9516,19 @@ pub unsafe fn sqlite3_bind_zeroblob( arg2: ::std::os::raw::c_int, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_bind_zeroblob, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).bind_zeroblob.expect(stringify!( + ((*p_api).bind_zeroblob.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_zeroblob", " function" @@ -9648,10 +9536,19 @@ pub unsafe fn sqlite3_bind_zeroblob( } pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_bytes, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_bytes.expect(stringify!( + ((*p_api).blob_bytes.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_bytes", " function" @@ -9659,10 +9556,19 @@ pub unsafe fn sqlite3_blob_bytes(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_i } pub unsafe fn sqlite3_blob_close(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_close, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_close.expect(stringify!( + ((*p_api).blob_close.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_close", " function" @@ -9678,10 +9584,19 @@ pub unsafe fn sqlite3_blob_open( arg6: ::std::os::raw::c_int, arg7: *mut *mut sqlite3_blob, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_open, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_open.expect(stringify!( + ((*p_api).blob_open.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_open", " function" @@ -9694,10 +9609,19 @@ pub unsafe fn sqlite3_blob_read( arg3: ::std::os::raw::c_int, arg4: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_read, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_read.expect(stringify!( + ((*p_api).blob_read.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_read", " function" @@ -9710,10 +9634,19 @@ pub unsafe fn sqlite3_blob_write( arg3: ::std::os::raw::c_int, arg4: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_write, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_write.expect(stringify!( + ((*p_api).blob_write.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_write", " function" @@ -9736,10 +9669,19 @@ pub unsafe fn sqlite3_create_collation_v2( >, arg6: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_create_collation_v2, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).create_collation_v2.expect(stringify!( + ((*p_api).create_collation_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "create_collation_v2", " function" @@ -9752,10 +9694,19 @@ pub unsafe fn sqlite3_file_control( arg3: ::std::os::raw::c_int, arg4: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_file_control, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).file_control.expect(stringify!( + ((*p_api).file_control.expect(stringify!( "sqlite3_api contains null pointer for ", "file_control", " function" @@ -9763,10 +9714,19 @@ pub unsafe fn sqlite3_file_control( } pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_memory_highwater, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).memory_highwater.expect(stringify!( + ((*p_api).memory_highwater.expect(stringify!( "sqlite3_api contains null pointer for ", "memory_highwater", " function" @@ -9774,10 +9734,19 @@ pub unsafe fn sqlite3_memory_highwater(arg1: ::std::os::raw::c_int) -> sqlite3_i } pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_memory_used, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).memory_used.expect(stringify!( + ((*p_api).memory_used.expect(stringify!( "sqlite3_api contains null pointer for ", "memory_used", " function" @@ -9785,10 +9754,19 @@ pub unsafe fn sqlite3_memory_used() -> sqlite3_int64 { } pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_mutex_alloc, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).mutex_alloc.expect(stringify!( + ((*p_api).mutex_alloc.expect(stringify!( "sqlite3_api contains null pointer for ", "mutex_alloc", " function" @@ -9796,10 +9774,19 @@ pub unsafe fn sqlite3_mutex_alloc(arg1: ::std::os::raw::c_int) -> *mut sqlite3_m } pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_mutex_enter, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).mutex_enter.expect(stringify!( + ((*p_api).mutex_enter.expect(stringify!( "sqlite3_api contains null pointer for ", "mutex_enter", " function" @@ -9807,10 +9794,19 @@ pub unsafe fn sqlite3_mutex_enter(arg1: *mut sqlite3_mutex) { } pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_mutex_free, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).mutex_free.expect(stringify!( + ((*p_api).mutex_free.expect(stringify!( "sqlite3_api contains null pointer for ", "mutex_free", " function" @@ -9818,10 +9814,19 @@ pub unsafe fn sqlite3_mutex_free(arg1: *mut sqlite3_mutex) { } pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_mutex_leave, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).mutex_leave.expect(stringify!( + ((*p_api).mutex_leave.expect(stringify!( "sqlite3_api contains null pointer for ", "mutex_leave", " function" @@ -9829,10 +9834,19 @@ pub unsafe fn sqlite3_mutex_leave(arg1: *mut sqlite3_mutex) { } pub unsafe fn sqlite3_mutex_try(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_mutex_try, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).mutex_try.expect(stringify!( + ((*p_api).mutex_try.expect(stringify!( "sqlite3_api contains null pointer for ", "mutex_try", " function" @@ -9845,10 +9859,19 @@ pub unsafe fn sqlite3_open_v2( arg3: ::std::os::raw::c_int, arg4: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_open_v2, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).open_v2.expect(stringify!( + ((*p_api).open_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "open_v2", " function" @@ -9856,10 +9879,19 @@ pub unsafe fn sqlite3_open_v2( } pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_release_memory, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).release_memory.expect(stringify!( + ((*p_api).release_memory.expect(stringify!( "sqlite3_api contains null pointer for ", "release_memory", " function" @@ -9867,10 +9899,19 @@ pub unsafe fn sqlite3_release_memory(arg1: ::std::os::raw::c_int) -> ::std::os:: } pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_result_error_nomem, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).result_error_nomem.expect(stringify!( + ((*p_api).result_error_nomem.expect(stringify!( "sqlite3_api contains null pointer for ", "result_error_nomem", " function" @@ -9878,10 +9919,19 @@ pub unsafe fn sqlite3_result_error_nomem(arg1: *mut sqlite3_context) { } pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_result_error_toobig, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).result_error_toobig.expect(stringify!( + ((*p_api).result_error_toobig.expect(stringify!( "sqlite3_api contains null pointer for ", "result_error_toobig", " function" @@ -9889,10 +9939,19 @@ pub unsafe fn sqlite3_result_error_toobig(arg1: *mut sqlite3_context) { } pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_sleep, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).sleep.expect(stringify!( + ((*p_api).sleep.expect(stringify!( "sqlite3_api contains null pointer for ", "sleep", " function" @@ -9900,10 +9959,19 @@ pub unsafe fn sqlite3_sleep(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_in } pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_soft_heap_limit, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).soft_heap_limit.expect(stringify!( + ((*p_api).soft_heap_limit.expect(stringify!( "sqlite3_api contains null pointer for ", "soft_heap_limit", " function" @@ -9911,10 +9979,19 @@ pub unsafe fn sqlite3_soft_heap_limit(arg1: ::std::os::raw::c_int) { } pub unsafe fn sqlite3_vfs_find(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_vfs_find, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).vfs_find.expect(stringify!( + ((*p_api).vfs_find.expect(stringify!( "sqlite3_api contains null pointer for ", "vfs_find", " function" @@ -9925,10 +10002,19 @@ pub unsafe fn sqlite3_vfs_register( arg1: *mut sqlite3_vfs, arg2: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_vfs_register, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).vfs_register.expect(stringify!( + ((*p_api).vfs_register.expect(stringify!( "sqlite3_api contains null pointer for ", "vfs_register", " function" @@ -9936,10 +10022,19 @@ pub unsafe fn sqlite3_vfs_register( } pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_vfs_unregister, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).vfs_unregister.expect(stringify!( + ((*p_api).vfs_unregister.expect(stringify!( "sqlite3_api contains null pointer for ", "vfs_unregister", " function" @@ -9947,10 +10042,19 @@ pub unsafe fn sqlite3_vfs_unregister(arg1: *mut sqlite3_vfs) -> ::std::os::raw:: } pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_xthreadsafe, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).xthreadsafe.expect(stringify!( + ((*p_api).xthreadsafe.expect(stringify!( "sqlite3_api contains null pointer for ", "xthreadsafe", " function" @@ -9958,10 +10062,19 @@ pub unsafe fn sqlite3_xthreadsafe() -> ::std::os::raw::c_int { } pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_result_zeroblob, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).result_zeroblob.expect(stringify!( + ((*p_api).result_zeroblob.expect(stringify!( "sqlite3_api contains null pointer for ", "result_zeroblob", " function" @@ -9969,10 +10082,19 @@ pub unsafe fn sqlite3_result_zeroblob(arg1: *mut sqlite3_context, arg2: ::std::o } pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_result_error_code, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).result_error_code.expect(stringify!( + ((*p_api).result_error_code.expect(stringify!( "sqlite3_api contains null pointer for ", "result_error_code", " function" @@ -9980,10 +10102,19 @@ pub unsafe fn sqlite3_result_error_code(arg1: *mut sqlite3_context, arg2: ::std: } pub unsafe fn sqlite3_test_control(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_test_control, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).test_control.expect(stringify!( + ((*p_api).test_control.expect(stringify!( "sqlite3_api contains null pointer for ", "test_control", " function" @@ -9991,10 +10122,19 @@ pub unsafe fn sqlite3_test_control(arg1: ::std::os::raw::c_int) -> ::std::os::ra } pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_randomness, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).randomness.expect(stringify!( + ((*p_api).randomness.expect(stringify!( "sqlite3_api contains null pointer for ", "randomness", " function" @@ -10002,10 +10142,19 @@ pub unsafe fn sqlite3_randomness(arg1: ::std::os::raw::c_int, arg2: *mut ::std:: } pub unsafe fn sqlite3_context_db_handle(arg1: *mut sqlite3_context) -> *mut sqlite3 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_context_db_handle, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).context_db_handle.expect(stringify!( + ((*p_api).context_db_handle.expect(stringify!( "sqlite3_api contains null pointer for ", "context_db_handle", " function" @@ -10016,10 +10165,19 @@ pub unsafe fn sqlite3_extended_result_codes( arg1: *mut sqlite3, arg2: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_extended_result_codes, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).extended_result_codes.expect(stringify!( + ((*p_api).extended_result_codes.expect(stringify!( "sqlite3_api contains null pointer for ", "extended_result_codes", " function" @@ -10031,10 +10189,19 @@ pub unsafe fn sqlite3_limit( arg2: ::std::os::raw::c_int, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_limit, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).limit.expect(stringify!( + ((*p_api).limit.expect(stringify!( "sqlite3_api contains null pointer for ", "limit", " function" @@ -10042,10 +10209,19 @@ pub unsafe fn sqlite3_limit( } pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_next_stmt, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).next_stmt.expect(stringify!( + ((*p_api).next_stmt.expect(stringify!( "sqlite3_api contains null pointer for ", "next_stmt", " function" @@ -10053,10 +10229,19 @@ pub unsafe fn sqlite3_next_stmt(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> } pub unsafe fn sqlite3_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_sql, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).sql.expect(stringify!( + ((*p_api).sql.expect(stringify!( "sqlite3_api contains null pointer for ", "sql", " function" @@ -10069,10 +10254,19 @@ pub unsafe fn sqlite3_status( arg3: *mut ::std::os::raw::c_int, arg4: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_status, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).status.expect(stringify!( + ((*p_api).status.expect(stringify!( "sqlite3_api contains null pointer for ", "status", " function" @@ -10080,10 +10274,19 @@ pub unsafe fn sqlite3_status( } pub unsafe fn sqlite3_backup_finish(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_backup_finish, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).backup_finish.expect(stringify!( + ((*p_api).backup_finish.expect(stringify!( "sqlite3_api contains null pointer for ", "backup_finish", " function" @@ -10096,10 +10299,19 @@ pub unsafe fn sqlite3_backup_init( arg3: *mut sqlite3, arg4: *const ::std::os::raw::c_char, ) -> *mut sqlite3_backup { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_backup_init, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).backup_init.expect(stringify!( + ((*p_api).backup_init.expect(stringify!( "sqlite3_api contains null pointer for ", "backup_init", " function" @@ -10107,10 +10319,19 @@ pub unsafe fn sqlite3_backup_init( } pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_backup_pagecount, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).backup_pagecount.expect(stringify!( + ((*p_api).backup_pagecount.expect(stringify!( "sqlite3_api contains null pointer for ", "backup_pagecount", " function" @@ -10118,10 +10339,19 @@ pub unsafe fn sqlite3_backup_pagecount(arg1: *mut sqlite3_backup) -> ::std::os:: } pub unsafe fn sqlite3_backup_remaining(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_backup_remaining, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).backup_remaining.expect(stringify!( + ((*p_api).backup_remaining.expect(stringify!( "sqlite3_api contains null pointer for ", "backup_remaining", " function" @@ -10132,10 +10362,19 @@ pub unsafe fn sqlite3_backup_step( arg1: *mut sqlite3_backup, arg2: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_backup_step, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).backup_step.expect(stringify!( + ((*p_api).backup_step.expect(stringify!( "sqlite3_api contains null pointer for ", "backup_step", " function" @@ -10145,10 +10384,19 @@ pub unsafe fn sqlite3_backup_step( pub unsafe fn sqlite3_compileoption_get( arg1: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_compileoption_get, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).compileoption_get.expect(stringify!( + ((*p_api).compileoption_get.expect(stringify!( "sqlite3_api contains null pointer for ", "compileoption_get", " function" @@ -10158,10 +10406,19 @@ pub unsafe fn sqlite3_compileoption_get( pub unsafe fn sqlite3_compileoption_used( arg1: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_compileoption_used, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).compileoption_used.expect(stringify!( + ((*p_api).compileoption_used.expect(stringify!( "sqlite3_api contains null pointer for ", "compileoption_used", " function" @@ -10191,10 +10448,19 @@ pub unsafe fn sqlite3_create_function_v2( xFinal: ::std::option::Option, xDestroy: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_create_function_v2, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).create_function_v2.expect(stringify!( + ((*p_api).create_function_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "create_function_v2", " function" @@ -10205,10 +10471,19 @@ pub unsafe fn sqlite3_db_config( arg1: *mut sqlite3, arg2: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_db_config, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).db_config.expect(stringify!( + ((*p_api).db_config.expect(stringify!( "sqlite3_api contains null pointer for ", "db_config", " function" @@ -10220,10 +10495,19 @@ pub unsafe fn sqlite3_db_config_constchar( arg2: ::std::os::raw::c_int, vararg1: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_db_config_constchar, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).db_config.expect(stringify!( + ((*p_api).db_config.expect(stringify!( "sqlite3_api contains null pointer for ", "db_config", " function" @@ -10236,10 +10520,19 @@ pub unsafe fn sqlite3_db_config_int_mutint( vararg1: ::std::os::raw::c_int, vararg2: *mut ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_db_config_int_mutint, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).db_config.expect(stringify!( + ((*p_api).db_config.expect(stringify!( "sqlite3_api contains null pointer for ", "db_config", " function" @@ -10253,10 +10546,19 @@ pub unsafe fn sqlite3_db_config_void_int_mutint( vararg2: ::std::os::raw::c_int, vararg3: *mut ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_db_config_void_int_mutint, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).db_config.expect(stringify!( + ((*p_api).db_config.expect(stringify!( "sqlite3_api contains null pointer for ", "db_config", " function" @@ -10264,10 +10566,19 @@ pub unsafe fn sqlite3_db_config_void_int_mutint( } pub unsafe fn sqlite3_db_mutex(arg1: *mut sqlite3) -> *mut sqlite3_mutex { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_db_mutex, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).db_mutex.expect(stringify!( + ((*p_api).db_mutex.expect(stringify!( "sqlite3_api contains null pointer for ", "db_mutex", " function" @@ -10281,10 +10592,19 @@ pub unsafe fn sqlite3_db_status( arg4: *mut ::std::os::raw::c_int, arg5: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_db_status, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).db_status.expect(stringify!( + ((*p_api).db_status.expect(stringify!( "sqlite3_api contains null pointer for ", "db_status", " function" @@ -10292,10 +10612,19 @@ pub unsafe fn sqlite3_db_status( } pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_extended_errcode, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).extended_errcode.expect(stringify!( + ((*p_api).extended_errcode.expect(stringify!( "sqlite3_api contains null pointer for ", "extended_errcode", " function" @@ -10303,10 +10632,19 @@ pub unsafe fn sqlite3_extended_errcode(arg1: *mut sqlite3) -> ::std::os::raw::c_ } pub unsafe fn sqlite3_log(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_log, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).log.expect(stringify!( + ((*p_api).log.expect(stringify!( "sqlite3_api contains null pointer for ", "log", " function" @@ -10314,10 +10652,19 @@ pub unsafe fn sqlite3_log(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::r } pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_soft_heap_limit64, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).soft_heap_limit64.expect(stringify!( + ((*p_api).soft_heap_limit64.expect(stringify!( "sqlite3_api contains null pointer for ", "soft_heap_limit64", " function" @@ -10325,10 +10672,19 @@ pub unsafe fn sqlite3_soft_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { } pub unsafe fn sqlite3_sourceid() -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_sourceid, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).sourceid.expect(stringify!( + ((*p_api).sourceid.expect(stringify!( "sqlite3_api contains null pointer for ", "sourceid", " function" @@ -10340,10 +10696,19 @@ pub unsafe fn sqlite3_stmt_status( arg2: ::std::os::raw::c_int, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_stmt_status, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).stmt_status.expect(stringify!( + ((*p_api).stmt_status.expect(stringify!( "sqlite3_api contains null pointer for ", "stmt_status", " function" @@ -10355,10 +10720,19 @@ pub unsafe fn sqlite3_strnicmp( arg2: *const ::std::os::raw::c_char, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_strnicmp, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).strnicmp.expect(stringify!( + ((*p_api).strnicmp.expect(stringify!( "sqlite3_api contains null pointer for ", "strnicmp", " function" @@ -10372,10 +10746,19 @@ pub unsafe fn sqlite3_unlock_notify( >, arg3: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_unlock_notify, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).unlock_notify.expect(stringify!( + ((*p_api).unlock_notify.expect(stringify!( "sqlite3_api contains null pointer for ", "unlock_notify", " function" @@ -10386,10 +10769,19 @@ pub unsafe fn sqlite3_wal_autocheckpoint( arg1: *mut sqlite3, arg2: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_wal_autocheckpoint, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).wal_autocheckpoint.expect(stringify!( + ((*p_api).wal_autocheckpoint.expect(stringify!( "sqlite3_api contains null pointer for ", "wal_autocheckpoint", " function" @@ -10400,10 +10792,19 @@ pub unsafe fn sqlite3_wal_checkpoint( arg1: *mut sqlite3, arg2: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_wal_checkpoint, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).wal_checkpoint.expect(stringify!( + ((*p_api).wal_checkpoint.expect(stringify!( "sqlite3_api contains null pointer for ", "wal_checkpoint", " function" @@ -10422,10 +10823,19 @@ pub unsafe fn sqlite3_wal_hook( >, arg3: *mut ::std::os::raw::c_void, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_wal_hook, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).wal_hook.expect(stringify!( + ((*p_api).wal_hook.expect(stringify!( "sqlite3_api contains null pointer for ", "wal_hook", " function" @@ -10436,10 +10846,19 @@ pub unsafe fn sqlite3_blob_reopen( arg1: *mut sqlite3_blob, arg2: sqlite3_int64, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_blob_reopen, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).blob_reopen.expect(stringify!( + ((*p_api).blob_reopen.expect(stringify!( "sqlite3_api contains null pointer for ", "blob_reopen", " function" @@ -10450,10 +10869,19 @@ pub unsafe fn sqlite3_vtab_config( arg1: *mut sqlite3, op: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_vtab_config, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).vtab_config.expect(stringify!( + ((*p_api).vtab_config.expect(stringify!( "sqlite3_api contains null pointer for ", "vtab_config", " function" @@ -10465,10 +10893,19 @@ pub unsafe fn sqlite3_vtab_config_int( op: ::std::os::raw::c_int, vararg1: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_vtab_config_int, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).vtab_config.expect(stringify!( + ((*p_api).vtab_config.expect(stringify!( "sqlite3_api contains null pointer for ", "vtab_config", " function" @@ -10476,10 +10913,19 @@ pub unsafe fn sqlite3_vtab_config_int( } pub unsafe fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3005000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_vtab_on_conflict, + " function" + ), + sqlite3_version_number, 3005000i32 + ); } - ((*sqlite3_api).vtab_on_conflict.expect(stringify!( + ((*p_api).vtab_on_conflict.expect(stringify!( "sqlite3_api contains null pointer for ", "vtab_on_conflict", " function" @@ -10487,10 +10933,19 @@ pub unsafe fn sqlite3_vtab_on_conflict(arg1: *mut sqlite3) -> ::std::os::raw::c_ } pub unsafe fn sqlite3_close_v2(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3007016i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_close_v2, + " function" + ), + sqlite3_version_number, 3007016i32 + ); } - ((*sqlite3_api).close_v2.expect(stringify!( + ((*p_api).close_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "close_v2", " function" @@ -10501,10 +10956,19 @@ pub unsafe fn sqlite3_db_filename( arg1: *mut sqlite3, arg2: *const ::std::os::raw::c_char, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3007016i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_db_filename, + " function" + ), + sqlite3_version_number, 3007016i32 + ); } - ((*sqlite3_api).db_filename.expect(stringify!( + ((*p_api).db_filename.expect(stringify!( "sqlite3_api contains null pointer for ", "db_filename", " function" @@ -10515,10 +10979,19 @@ pub unsafe fn sqlite3_db_readonly( arg1: *mut sqlite3, arg2: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3007016i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_db_readonly, + " function" + ), + sqlite3_version_number, 3007016i32 + ); } - ((*sqlite3_api).db_readonly.expect(stringify!( + ((*p_api).db_readonly.expect(stringify!( "sqlite3_api contains null pointer for ", "db_readonly", " function" @@ -10526,10 +10999,19 @@ pub unsafe fn sqlite3_db_readonly( } pub unsafe fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3007016i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_db_release_memory, + " function" + ), + sqlite3_version_number, 3007016i32 + ); } - ((*sqlite3_api).db_release_memory.expect(stringify!( + ((*p_api).db_release_memory.expect(stringify!( "sqlite3_api contains null pointer for ", "db_release_memory", " function" @@ -10537,10 +11019,19 @@ pub unsafe fn sqlite3_db_release_memory(arg1: *mut sqlite3) -> ::std::os::raw::c } pub unsafe fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3007016i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_errstr, + " function" + ), + sqlite3_version_number, 3007016i32 + ); } - ((*sqlite3_api).errstr.expect(stringify!( + ((*p_api).errstr.expect(stringify!( "sqlite3_api contains null pointer for ", "errstr", " function" @@ -10548,10 +11039,19 @@ pub unsafe fn sqlite3_errstr(arg1: ::std::os::raw::c_int) -> *const ::std::os::r } pub unsafe fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3007016i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_stmt_busy, + " function" + ), + sqlite3_version_number, 3007016i32 + ); } - ((*sqlite3_api).stmt_busy.expect(stringify!( + ((*p_api).stmt_busy.expect(stringify!( "sqlite3_api contains null pointer for ", "stmt_busy", " function" @@ -10559,10 +11059,19 @@ pub unsafe fn sqlite3_stmt_busy(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_in } pub unsafe fn sqlite3_stmt_readonly(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3007016i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_stmt_readonly, + " function" + ), + sqlite3_version_number, 3007016i32 + ); } - ((*sqlite3_api).stmt_readonly.expect(stringify!( + ((*p_api).stmt_readonly.expect(stringify!( "sqlite3_api contains null pointer for ", "stmt_readonly", " function" @@ -10573,10 +11082,19 @@ pub unsafe fn sqlite3_stricmp( arg1: *const ::std::os::raw::c_char, arg2: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3007016i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_stricmp, + " function" + ), + sqlite3_version_number, 3007016i32 + ); } - ((*sqlite3_api).stricmp.expect(stringify!( + ((*p_api).stricmp.expect(stringify!( "sqlite3_api contains null pointer for ", "stricmp", " function" @@ -10588,10 +11106,19 @@ pub unsafe fn sqlite3_uri_boolean( arg2: *const ::std::os::raw::c_char, arg3: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3007016i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_uri_boolean, + " function" + ), + sqlite3_version_number, 3007016i32 + ); } - ((*sqlite3_api).uri_boolean.expect(stringify!( + ((*p_api).uri_boolean.expect(stringify!( "sqlite3_api contains null pointer for ", "uri_boolean", " function" @@ -10603,10 +11130,19 @@ pub unsafe fn sqlite3_uri_int64( arg2: *const ::std::os::raw::c_char, arg3: sqlite3_int64, ) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3007016i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_uri_int64, + " function" + ), + sqlite3_version_number, 3007016i32 + ); } - ((*sqlite3_api).uri_int64.expect(stringify!( + ((*p_api).uri_int64.expect(stringify!( "sqlite3_api contains null pointer for ", "uri_int64", " function" @@ -10617,10 +11153,19 @@ pub unsafe fn sqlite3_uri_parameter( arg1: *const ::std::os::raw::c_char, arg2: *const ::std::os::raw::c_char, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3007016i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_uri_parameter, + " function" + ), + sqlite3_version_number, 3007016i32 + ); } - ((*sqlite3_api).uri_parameter.expect(stringify!( + ((*p_api).uri_parameter.expect(stringify!( "sqlite3_api contains null pointer for ", "uri_parameter", " function" @@ -10634,10 +11179,19 @@ pub unsafe fn sqlite3_wal_checkpoint_v2( arg4: *mut ::std::os::raw::c_int, arg5: *mut ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3007016i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_wal_checkpoint_v2, + " function" + ), + sqlite3_version_number, 3007016i32 + ); } - ((*sqlite3_api).wal_checkpoint_v2.expect(stringify!( + ((*p_api).wal_checkpoint_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "wal_checkpoint_v2", " function" @@ -10647,10 +11201,19 @@ pub unsafe fn sqlite3_wal_checkpoint_v2( pub unsafe fn sqlite3_auto_extension( arg1: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3008007i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_auto_extension, + " function" + ), + sqlite3_version_number, 3008007i32 + ); } - ((*sqlite3_api).auto_extension.expect(stringify!( + ((*p_api).auto_extension.expect(stringify!( "sqlite3_api contains null pointer for ", "auto_extension", " function" @@ -10664,10 +11227,19 @@ pub unsafe fn sqlite3_bind_blob64( arg4: sqlite3_uint64, arg5: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3008007i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_bind_blob64, + " function" + ), + sqlite3_version_number, 3008007i32 + ); } - ((*sqlite3_api).bind_blob64.expect(stringify!( + ((*p_api).bind_blob64.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_blob64", " function" @@ -10682,10 +11254,19 @@ pub unsafe fn sqlite3_bind_text64( arg5: ::std::option::Option, arg6: ::std::os::raw::c_uchar, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3008007i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_bind_text64, + " function" + ), + sqlite3_version_number, 3008007i32 + ); } - ((*sqlite3_api).bind_text64.expect(stringify!( + ((*p_api).bind_text64.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_text64", " function" @@ -10695,10 +11276,19 @@ pub unsafe fn sqlite3_bind_text64( pub unsafe fn sqlite3_cancel_auto_extension( arg1: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3008007i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_cancel_auto_extension, + " function" + ), + sqlite3_version_number, 3008007i32 + ); } - ((*sqlite3_api).cancel_auto_extension.expect(stringify!( + ((*p_api).cancel_auto_extension.expect(stringify!( "sqlite3_api contains null pointer for ", "cancel_auto_extension", " function" @@ -10711,10 +11301,19 @@ pub unsafe fn sqlite3_load_extension( arg3: *const ::std::os::raw::c_char, arg4: *mut *mut ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3008007i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_load_extension, + " function" + ), + sqlite3_version_number, 3008007i32 + ); } - ((*sqlite3_api).load_extension.expect(stringify!( + ((*p_api).load_extension.expect(stringify!( "sqlite3_api contains null pointer for ", "load_extension", " function" @@ -10722,10 +11321,19 @@ pub unsafe fn sqlite3_load_extension( } pub unsafe fn sqlite3_malloc64(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3008007i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_malloc64, + " function" + ), + sqlite3_version_number, 3008007i32 + ); } - ((*sqlite3_api).malloc64.expect(stringify!( + ((*p_api).malloc64.expect(stringify!( "sqlite3_api contains null pointer for ", "malloc64", " function" @@ -10733,10 +11341,19 @@ pub unsafe fn sqlite3_malloc64(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_v } pub unsafe fn sqlite3_msize(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3008007i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_msize, + " function" + ), + sqlite3_version_number, 3008007i32 + ); } - ((*sqlite3_api).msize.expect(stringify!( + ((*p_api).msize.expect(stringify!( "sqlite3_api contains null pointer for ", "msize", " function" @@ -10747,10 +11364,19 @@ pub unsafe fn sqlite3_realloc64( arg1: *mut ::std::os::raw::c_void, arg2: sqlite3_uint64, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3008007i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_realloc64, + " function" + ), + sqlite3_version_number, 3008007i32 + ); } - ((*sqlite3_api).realloc64.expect(stringify!( + ((*p_api).realloc64.expect(stringify!( "sqlite3_api contains null pointer for ", "realloc64", " function" @@ -10758,10 +11384,19 @@ pub unsafe fn sqlite3_realloc64( } pub unsafe fn sqlite3_reset_auto_extension() { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3008007i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_reset_auto_extension, + " function" + ), + sqlite3_version_number, 3008007i32 + ); } - ((*sqlite3_api).reset_auto_extension.expect(stringify!( + ((*p_api).reset_auto_extension.expect(stringify!( "sqlite3_api contains null pointer for ", "reset_auto_extension", " function" @@ -10774,10 +11409,19 @@ pub unsafe fn sqlite3_result_blob64( arg3: sqlite3_uint64, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3008007i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_result_blob64, + " function" + ), + sqlite3_version_number, 3008007i32 + ); } - ((*sqlite3_api).result_blob64.expect(stringify!( + ((*p_api).result_blob64.expect(stringify!( "sqlite3_api contains null pointer for ", "result_blob64", " function" @@ -10791,10 +11435,19 @@ pub unsafe fn sqlite3_result_text64( arg4: ::std::option::Option, arg5: ::std::os::raw::c_uchar, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3008007i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_result_text64, + " function" + ), + sqlite3_version_number, 3008007i32 + ); } - ((*sqlite3_api).result_text64.expect(stringify!( + ((*p_api).result_text64.expect(stringify!( "sqlite3_api contains null pointer for ", "result_text64", " function" @@ -10805,10 +11458,19 @@ pub unsafe fn sqlite3_strglob( arg1: *const ::std::os::raw::c_char, arg2: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3008007i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_strglob, + " function" + ), + sqlite3_version_number, 3008007i32 + ); } - ((*sqlite3_api).strglob.expect(stringify!( + ((*p_api).strglob.expect(stringify!( "sqlite3_api contains null pointer for ", "strglob", " function" @@ -10816,10 +11478,19 @@ pub unsafe fn sqlite3_strglob( } pub unsafe fn sqlite3_value_dup(arg1: *const sqlite3_value) -> *mut sqlite3_value { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3008011i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_value_dup, + " function" + ), + sqlite3_version_number, 3008011i32 + ); } - ((*sqlite3_api).value_dup.expect(stringify!( + ((*p_api).value_dup.expect(stringify!( "sqlite3_api contains null pointer for ", "value_dup", " function" @@ -10827,10 +11498,19 @@ pub unsafe fn sqlite3_value_dup(arg1: *const sqlite3_value) -> *mut sqlite3_valu } pub unsafe fn sqlite3_value_free(arg1: *mut sqlite3_value) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3008011i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_value_free, + " function" + ), + sqlite3_version_number, 3008011i32 + ); } - ((*sqlite3_api).value_free.expect(stringify!( + ((*p_api).value_free.expect(stringify!( "sqlite3_api contains null pointer for ", "value_free", " function" @@ -10841,10 +11521,19 @@ pub unsafe fn sqlite3_result_zeroblob64( arg1: *mut sqlite3_context, arg2: sqlite3_uint64, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3008011i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_result_zeroblob64, + " function" + ), + sqlite3_version_number, 3008011i32 + ); } - ((*sqlite3_api).result_zeroblob64.expect(stringify!( + ((*p_api).result_zeroblob64.expect(stringify!( "sqlite3_api contains null pointer for ", "result_zeroblob64", " function" @@ -10856,10 +11545,19 @@ pub unsafe fn sqlite3_bind_zeroblob64( arg2: ::std::os::raw::c_int, arg3: sqlite3_uint64, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3008011i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_bind_zeroblob64, + " function" + ), + sqlite3_version_number, 3008011i32 + ); } - ((*sqlite3_api).bind_zeroblob64.expect(stringify!( + ((*p_api).bind_zeroblob64.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_zeroblob64", " function" @@ -10867,10 +11565,19 @@ pub unsafe fn sqlite3_bind_zeroblob64( } pub unsafe fn sqlite3_value_subtype(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3009000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_value_subtype, + " function" + ), + sqlite3_version_number, 3009000i32 + ); } - ((*sqlite3_api).value_subtype.expect(stringify!( + ((*p_api).value_subtype.expect(stringify!( "sqlite3_api contains null pointer for ", "value_subtype", " function" @@ -10878,10 +11585,19 @@ pub unsafe fn sqlite3_value_subtype(arg1: *mut sqlite3_value) -> ::std::os::raw: } pub unsafe fn sqlite3_result_subtype(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3009000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_result_subtype, + " function" + ), + sqlite3_version_number, 3009000i32 + ); } - ((*sqlite3_api).result_subtype.expect(stringify!( + ((*p_api).result_subtype.expect(stringify!( "sqlite3_api contains null pointer for ", "result_subtype", " function" @@ -10894,10 +11610,19 @@ pub unsafe fn sqlite3_status64( arg3: *mut sqlite3_int64, arg4: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3010000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_status64, + " function" + ), + sqlite3_version_number, 3010000i32 + ); } - ((*sqlite3_api).status64.expect(stringify!( + ((*p_api).status64.expect(stringify!( "sqlite3_api contains null pointer for ", "status64", " function" @@ -10909,10 +11634,19 @@ pub unsafe fn sqlite3_strlike( arg2: *const ::std::os::raw::c_char, arg3: ::std::os::raw::c_uint, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3010000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_strlike, + " function" + ), + sqlite3_version_number, 3010000i32 + ); } - ((*sqlite3_api).strlike.expect(stringify!( + ((*p_api).strlike.expect(stringify!( "sqlite3_api contains null pointer for ", "strlike", " function" @@ -10920,10 +11654,19 @@ pub unsafe fn sqlite3_strlike( } pub unsafe fn sqlite3_db_cacheflush(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3010000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_db_cacheflush, + " function" + ), + sqlite3_version_number, 3010000i32 + ); } - ((*sqlite3_api).db_cacheflush.expect(stringify!( + ((*p_api).db_cacheflush.expect(stringify!( "sqlite3_api contains null pointer for ", "db_cacheflush", " function" @@ -10931,10 +11674,19 @@ pub unsafe fn sqlite3_db_cacheflush(arg1: *mut sqlite3) -> ::std::os::raw::c_int } pub unsafe fn sqlite3_system_errno(arg1: *mut sqlite3) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3012000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_system_errno, + " function" + ), + sqlite3_version_number, 3012000i32 + ); } - ((*sqlite3_api).system_errno.expect(stringify!( + ((*p_api).system_errno.expect(stringify!( "sqlite3_api contains null pointer for ", "system_errno", " function" @@ -10954,10 +11706,19 @@ pub unsafe fn sqlite3_trace_v2( >, arg4: *mut ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3014000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_trace_v2, + " function" + ), + sqlite3_version_number, 3014000i32 + ); } - ((*sqlite3_api).trace_v2.expect(stringify!( + ((*p_api).trace_v2.expect(stringify!( "sqlite3_api contains null pointer for ", "trace_v2", " function" @@ -10965,10 +11726,19 @@ pub unsafe fn sqlite3_trace_v2( } pub unsafe fn sqlite3_expanded_sql(arg1: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3014000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_expanded_sql, + " function" + ), + sqlite3_version_number, 3014000i32 + ); } - ((*sqlite3_api).expanded_sql.expect(stringify!( + ((*p_api).expanded_sql.expect(stringify!( "sqlite3_api contains null pointer for ", "expanded_sql", " function" @@ -10976,10 +11746,19 @@ pub unsafe fn sqlite3_expanded_sql(arg1: *mut sqlite3_stmt) -> *mut ::std::os::r } pub unsafe fn sqlite3_set_last_insert_rowid(arg1: *mut sqlite3, arg2: sqlite3_int64) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3018000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_set_last_insert_rowid, + " function" + ), + sqlite3_version_number, 3018000i32 + ); } - ((*sqlite3_api).set_last_insert_rowid.expect(stringify!( + ((*p_api).set_last_insert_rowid.expect(stringify!( "sqlite3_api contains null pointer for ", "set_last_insert_rowid", " function" @@ -10994,10 +11773,19 @@ pub unsafe fn sqlite3_prepare_v3( arg5: *mut *mut sqlite3_stmt, arg6: *mut *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3020000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_prepare_v3, + " function" + ), + sqlite3_version_number, 3020000i32 + ); } - ((*sqlite3_api).prepare_v3.expect(stringify!( + ((*p_api).prepare_v3.expect(stringify!( "sqlite3_api contains null pointer for ", "prepare_v3", " function" @@ -11012,10 +11800,19 @@ pub unsafe fn sqlite3_prepare16_v3( arg5: *mut *mut sqlite3_stmt, arg6: *mut *const ::std::os::raw::c_void, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3020000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_prepare16_v3, + " function" + ), + sqlite3_version_number, 3020000i32 + ); } - ((*sqlite3_api).prepare16_v3.expect(stringify!( + ((*p_api).prepare16_v3.expect(stringify!( "sqlite3_api contains null pointer for ", "prepare16_v3", " function" @@ -11029,10 +11826,19 @@ pub unsafe fn sqlite3_bind_pointer( arg4: *const ::std::os::raw::c_char, arg5: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3020000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_bind_pointer, + " function" + ), + sqlite3_version_number, 3020000i32 + ); } - ((*sqlite3_api).bind_pointer.expect(stringify!( + ((*p_api).bind_pointer.expect(stringify!( "sqlite3_api contains null pointer for ", "bind_pointer", " function" @@ -11045,10 +11851,19 @@ pub unsafe fn sqlite3_result_pointer( arg3: *const ::std::os::raw::c_char, arg4: ::std::option::Option, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3020000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_result_pointer, + " function" + ), + sqlite3_version_number, 3020000i32 + ); } - ((*sqlite3_api).result_pointer.expect(stringify!( + ((*p_api).result_pointer.expect(stringify!( "sqlite3_api contains null pointer for ", "result_pointer", " function" @@ -11059,10 +11874,19 @@ pub unsafe fn sqlite3_value_pointer( arg1: *mut sqlite3_value, arg2: *const ::std::os::raw::c_char, ) -> *mut ::std::os::raw::c_void { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3020000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_value_pointer, + " function" + ), + sqlite3_version_number, 3020000i32 + ); } - ((*sqlite3_api).value_pointer.expect(stringify!( + ((*p_api).value_pointer.expect(stringify!( "sqlite3_api contains null pointer for ", "value_pointer", " function" @@ -11070,10 +11894,19 @@ pub unsafe fn sqlite3_value_pointer( } pub unsafe fn sqlite3_vtab_nochange(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3020000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_vtab_nochange, + " function" + ), + sqlite3_version_number, 3020000i32 + ); } - ((*sqlite3_api).vtab_nochange.expect(stringify!( + ((*p_api).vtab_nochange.expect(stringify!( "sqlite3_api contains null pointer for ", "vtab_nochange", " function" @@ -11081,10 +11914,19 @@ pub unsafe fn sqlite3_vtab_nochange(arg1: *mut sqlite3_context) -> ::std::os::ra } pub unsafe fn sqlite3_value_nochange(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3020000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_value_nochange, + " function" + ), + sqlite3_version_number, 3020000i32 + ); } - ((*sqlite3_api).value_nochange.expect(stringify!( + ((*p_api).value_nochange.expect(stringify!( "sqlite3_api contains null pointer for ", "value_nochange", " function" @@ -11095,10 +11937,19 @@ pub unsafe fn sqlite3_vtab_collation( arg1: *mut sqlite3_index_info, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3020000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_vtab_collation, + " function" + ), + sqlite3_version_number, 3020000i32 + ); } - ((*sqlite3_api).vtab_collation.expect(stringify!( + ((*p_api).vtab_collation.expect(stringify!( "sqlite3_api contains null pointer for ", "vtab_collation", " function" @@ -11106,10 +11957,19 @@ pub unsafe fn sqlite3_vtab_collation( } pub unsafe fn sqlite3_keyword_count() -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3024000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_keyword_count, + " function" + ), + sqlite3_version_number, 3024000i32 + ); } - ((*sqlite3_api).keyword_count.expect(stringify!( + ((*p_api).keyword_count.expect(stringify!( "sqlite3_api contains null pointer for ", "keyword_count", " function" @@ -11121,10 +11981,19 @@ pub unsafe fn sqlite3_keyword_name( arg2: *mut *const ::std::os::raw::c_char, arg3: *mut ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3024000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_keyword_name, + " function" + ), + sqlite3_version_number, 3024000i32 + ); } - ((*sqlite3_api).keyword_name.expect(stringify!( + ((*p_api).keyword_name.expect(stringify!( "sqlite3_api contains null pointer for ", "keyword_name", " function" @@ -11135,10 +12004,19 @@ pub unsafe fn sqlite3_keyword_check( arg1: *const ::std::os::raw::c_char, arg2: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3024000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_keyword_check, + " function" + ), + sqlite3_version_number, 3024000i32 + ); } - ((*sqlite3_api).keyword_check.expect(stringify!( + ((*p_api).keyword_check.expect(stringify!( "sqlite3_api contains null pointer for ", "keyword_check", " function" @@ -11146,10 +12024,19 @@ pub unsafe fn sqlite3_keyword_check( } pub unsafe fn sqlite3_str_new(arg1: *mut sqlite3) -> *mut sqlite3_str { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3024000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_str_new, + " function" + ), + sqlite3_version_number, 3024000i32 + ); } - ((*sqlite3_api).str_new.expect(stringify!( + ((*p_api).str_new.expect(stringify!( "sqlite3_api contains null pointer for ", "str_new", " function" @@ -11157,10 +12044,19 @@ pub unsafe fn sqlite3_str_new(arg1: *mut sqlite3) -> *mut sqlite3_str { } pub unsafe fn sqlite3_str_finish(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3024000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_str_finish, + " function" + ), + sqlite3_version_number, 3024000i32 + ); } - ((*sqlite3_api).str_finish.expect(stringify!( + ((*p_api).str_finish.expect(stringify!( "sqlite3_api contains null pointer for ", "str_finish", " function" @@ -11168,10 +12064,19 @@ pub unsafe fn sqlite3_str_finish(arg1: *mut sqlite3_str) -> *mut ::std::os::raw: } pub unsafe fn sqlite3_str_appendf(arg1: *mut sqlite3_str, zFormat: *const ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3024000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_str_appendf, + " function" + ), + sqlite3_version_number, 3024000i32 + ); } - ((*sqlite3_api).str_appendf.expect(stringify!( + ((*p_api).str_appendf.expect(stringify!( "sqlite3_api contains null pointer for ", "str_appendf", " function" @@ -11183,10 +12088,19 @@ pub unsafe fn sqlite3_str_append( zIn: *const ::std::os::raw::c_char, N: ::std::os::raw::c_int, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3024000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_str_append, + " function" + ), + sqlite3_version_number, 3024000i32 + ); } - ((*sqlite3_api).str_append.expect(stringify!( + ((*p_api).str_append.expect(stringify!( "sqlite3_api contains null pointer for ", "str_append", " function" @@ -11194,10 +12108,19 @@ pub unsafe fn sqlite3_str_append( } pub unsafe fn sqlite3_str_appendall(arg1: *mut sqlite3_str, zIn: *const ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3024000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_str_appendall, + " function" + ), + sqlite3_version_number, 3024000i32 + ); } - ((*sqlite3_api).str_appendall.expect(stringify!( + ((*p_api).str_appendall.expect(stringify!( "sqlite3_api contains null pointer for ", "str_appendall", " function" @@ -11209,10 +12132,19 @@ pub unsafe fn sqlite3_str_appendchar( N: ::std::os::raw::c_int, C: ::std::os::raw::c_char, ) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3024000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_str_appendchar, + " function" + ), + sqlite3_version_number, 3024000i32 + ); } - ((*sqlite3_api).str_appendchar.expect(stringify!( + ((*p_api).str_appendchar.expect(stringify!( "sqlite3_api contains null pointer for ", "str_appendchar", " function" @@ -11220,10 +12152,19 @@ pub unsafe fn sqlite3_str_appendchar( } pub unsafe fn sqlite3_str_reset(arg1: *mut sqlite3_str) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3024000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_str_reset, + " function" + ), + sqlite3_version_number, 3024000i32 + ); } - ((*sqlite3_api).str_reset.expect(stringify!( + ((*p_api).str_reset.expect(stringify!( "sqlite3_api contains null pointer for ", "str_reset", " function" @@ -11231,10 +12172,19 @@ pub unsafe fn sqlite3_str_reset(arg1: *mut sqlite3_str) { } pub unsafe fn sqlite3_str_errcode(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3024000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_str_errcode, + " function" + ), + sqlite3_version_number, 3024000i32 + ); } - ((*sqlite3_api).str_errcode.expect(stringify!( + ((*p_api).str_errcode.expect(stringify!( "sqlite3_api contains null pointer for ", "str_errcode", " function" @@ -11242,10 +12192,19 @@ pub unsafe fn sqlite3_str_errcode(arg1: *mut sqlite3_str) -> ::std::os::raw::c_i } pub unsafe fn sqlite3_str_length(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3024000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_str_length, + " function" + ), + sqlite3_version_number, 3024000i32 + ); } - ((*sqlite3_api).str_length.expect(stringify!( + ((*p_api).str_length.expect(stringify!( "sqlite3_api contains null pointer for ", "str_length", " function" @@ -11253,10 +12212,19 @@ pub unsafe fn sqlite3_str_length(arg1: *mut sqlite3_str) -> ::std::os::raw::c_in } pub unsafe fn sqlite3_str_value(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3024000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_str_value, + " function" + ), + sqlite3_version_number, 3024000i32 + ); } - ((*sqlite3_api).str_value.expect(stringify!( + ((*p_api).str_value.expect(stringify!( "sqlite3_api contains null pointer for ", "str_value", " function" @@ -11287,10 +12255,19 @@ pub unsafe fn sqlite3_create_window_function( >, xDestroy: ::std::option::Option, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3025000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_create_window_function, + " function" + ), + sqlite3_version_number, 3025000i32 + ); } - ((*sqlite3_api).create_window_function.expect(stringify!( + ((*p_api).create_window_function.expect(stringify!( "sqlite3_api contains null pointer for ", "create_window_function", " function" @@ -11300,10 +12277,19 @@ pub unsafe fn sqlite3_create_window_function( } pub unsafe fn sqlite3_normalized_sql(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3026000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_normalized_sql, + " function" + ), + sqlite3_version_number, 3026000i32 + ); } - ((*sqlite3_api).normalized_sql.expect(stringify!( + ((*p_api).normalized_sql.expect(stringify!( "sqlite3_api contains null pointer for ", "normalized_sql", " function" @@ -11311,10 +12297,19 @@ pub unsafe fn sqlite3_normalized_sql(arg1: *mut sqlite3_stmt) -> *const ::std::o } pub unsafe fn sqlite3_stmt_isexplain(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3028000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_stmt_isexplain, + " function" + ), + sqlite3_version_number, 3028000i32 + ); } - ((*sqlite3_api).stmt_isexplain.expect(stringify!( + ((*p_api).stmt_isexplain.expect(stringify!( "sqlite3_api contains null pointer for ", "stmt_isexplain", " function" @@ -11322,10 +12317,19 @@ pub unsafe fn sqlite3_stmt_isexplain(arg1: *mut sqlite3_stmt) -> ::std::os::raw: } pub unsafe fn sqlite3_value_frombind(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3028000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_value_frombind, + " function" + ), + sqlite3_version_number, 3028000i32 + ); } - ((*sqlite3_api).value_frombind.expect(stringify!( + ((*p_api).value_frombind.expect(stringify!( "sqlite3_api contains null pointer for ", "value_frombind", " function" @@ -11336,10 +12340,19 @@ pub unsafe fn sqlite3_drop_modules( arg1: *mut sqlite3, arg2: *mut *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3030000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_drop_modules, + " function" + ), + sqlite3_version_number, 3030000i32 + ); } - ((*sqlite3_api).drop_modules.expect(stringify!( + ((*p_api).drop_modules.expect(stringify!( "sqlite3_api contains null pointer for ", "drop_modules", " function" @@ -11347,10 +12360,19 @@ pub unsafe fn sqlite3_drop_modules( } pub unsafe fn sqlite3_hard_heap_limit64(arg1: sqlite3_int64) -> sqlite3_int64 { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3031000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_hard_heap_limit64, + " function" + ), + sqlite3_version_number, 3031000i32 + ); } - ((*sqlite3_api).hard_heap_limit64.expect(stringify!( + ((*p_api).hard_heap_limit64.expect(stringify!( "sqlite3_api contains null pointer for ", "hard_heap_limit64", " function" @@ -11361,10 +12383,19 @@ pub unsafe fn sqlite3_uri_key( arg1: *const ::std::os::raw::c_char, arg2: ::std::os::raw::c_int, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3031000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_uri_key, + " function" + ), + sqlite3_version_number, 3031000i32 + ); } - ((*sqlite3_api).uri_key.expect(stringify!( + ((*p_api).uri_key.expect(stringify!( "sqlite3_api contains null pointer for ", "uri_key", " function" @@ -11374,10 +12405,19 @@ pub unsafe fn sqlite3_uri_key( pub unsafe fn sqlite3_filename_database( arg1: *const ::std::os::raw::c_char, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3031000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_filename_database, + " function" + ), + sqlite3_version_number, 3031000i32 + ); } - ((*sqlite3_api).filename_database.expect(stringify!( + ((*p_api).filename_database.expect(stringify!( "sqlite3_api contains null pointer for ", "filename_database", " function" @@ -11387,10 +12427,19 @@ pub unsafe fn sqlite3_filename_database( pub unsafe fn sqlite3_filename_journal( arg1: *const ::std::os::raw::c_char, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3031000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_filename_journal, + " function" + ), + sqlite3_version_number, 3031000i32 + ); } - ((*sqlite3_api).filename_journal.expect(stringify!( + ((*p_api).filename_journal.expect(stringify!( "sqlite3_api contains null pointer for ", "filename_journal", " function" @@ -11400,10 +12449,19 @@ pub unsafe fn sqlite3_filename_journal( pub unsafe fn sqlite3_filename_wal( arg1: *const ::std::os::raw::c_char, ) -> *const ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3031000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_filename_wal, + " function" + ), + sqlite3_version_number, 3031000i32 + ); } - ((*sqlite3_api).filename_wal.expect(stringify!( + ((*p_api).filename_wal.expect(stringify!( "sqlite3_api contains null pointer for ", "filename_wal", " function" @@ -11417,10 +12475,19 @@ pub unsafe fn sqlite3_create_filename( arg4: ::std::os::raw::c_int, arg5: *mut *const ::std::os::raw::c_char, ) -> *mut ::std::os::raw::c_char { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3032000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_create_filename, + " function" + ), + sqlite3_version_number, 3032000i32 + ); } - ((*sqlite3_api).create_filename.expect(stringify!( + ((*p_api).create_filename.expect(stringify!( "sqlite3_api contains null pointer for ", "create_filename", " function" @@ -11428,10 +12495,19 @@ pub unsafe fn sqlite3_create_filename( } pub unsafe fn sqlite3_free_filename(arg1: *mut ::std::os::raw::c_char) { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3032000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_free_filename, + " function" + ), + sqlite3_version_number, 3032000i32 + ); } - ((*sqlite3_api).free_filename.expect(stringify!( + ((*p_api).free_filename.expect(stringify!( "sqlite3_api contains null pointer for ", "free_filename", " function" @@ -11441,10 +12517,19 @@ pub unsafe fn sqlite3_free_filename(arg1: *mut ::std::os::raw::c_char) { pub unsafe fn sqlite3_database_file_object( arg1: *const ::std::os::raw::c_char, ) -> *mut sqlite3_file { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3032000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_database_file_object, + " function" + ), + sqlite3_version_number, 3032000i32 + ); } - ((*sqlite3_api).database_file_object.expect(stringify!( + ((*p_api).database_file_object.expect(stringify!( "sqlite3_api contains null pointer for ", "database_file_object", " function" @@ -11455,12 +12540,94 @@ pub unsafe fn sqlite3_txn_state( arg1: *mut sqlite3, arg2: *const ::std::os::raw::c_char, ) -> ::std::os::raw::c_int { - if sqlite3_api.is_null() { - panic!("sqlite3_api is null"); + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3034000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_txn_state, + " function" + ), + sqlite3_version_number, 3034000i32 + ); } - ((*sqlite3_api).txn_state.expect(stringify!( + ((*p_api).txn_state.expect(stringify!( "sqlite3_api contains null pointer for ", "txn_state", " function" )))(arg1, arg2) } + +pub unsafe fn sqlite3_changes64(arg1: *mut sqlite3) -> sqlite3_int64 { + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3036001i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_changes64, + " function" + ), + sqlite3_version_number, 3036001i32 + ); + } + ((*p_api).changes64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "changes64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_total_changes64(arg1: *mut sqlite3) -> sqlite3_int64 { + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3036001i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_total_changes64, + " function" + ), + sqlite3_version_number, 3036001i32 + ); + } + ((*p_api).total_changes64.expect(stringify!( + "sqlite3_api contains null pointer for ", + "total_changes64", + " function" + )))(arg1) +} + +pub unsafe fn sqlite3_autovacuum_pages( + arg1: *mut sqlite3, + arg2: ::std::option::Option< + unsafe extern "C" fn( + arg1: *mut ::std::os::raw::c_void, + arg2: *const ::std::os::raw::c_char, + arg3: ::std::os::raw::c_uint, + arg4: ::std::os::raw::c_uint, + arg5: ::std::os::raw::c_uint, + ) -> ::std::os::raw::c_uint, + >, + arg3: *mut ::std::os::raw::c_void, + arg4: ::std::option::Option, +) -> ::std::os::raw::c_int { + let p_api = loadable_extension_sqlite3_api(); + let sqlite3_version_number = sqlite3_libversion_number(); + if sqlite3_version_number < 3037000i32 { + panic!( + stringify!( + "sqlite3 version is {} but version {} is required for the ", + sqlite3_autovacuum_pages, + " function" + ), + sqlite3_version_number, 3037000i32 + ); + } + ((*p_api).autovacuum_pages.expect(stringify!( + "sqlite3_api contains null pointer for ", + "autovacuum_pages", + " function" + )))(arg1, arg2, arg3, arg4) +} diff --git a/libsqlite3-sys/src/lib.rs b/libsqlite3-sys/src/lib.rs index f60cae92e..1ce3238e8 100644 --- a/libsqlite3-sys/src/lib.rs +++ b/libsqlite3-sys/src/lib.rs @@ -56,24 +56,17 @@ pub enum Limit { SQLITE_LIMIT_WORKER_THREADS = 11, } -#[cfg(feature = "loadable_extension_embedded")] -// bindings were built with loadable_extension_embedded: -// define sqlite3_api as an extern since this code will be embedded -// within a loadable extension that defines and exports this itself -extern "C" { - pub static mut sqlite3_api: *mut sqlite3_api_routines; -} +#[cfg(feature = "loadable_extension")] +mod loadable_extension; + +#[cfg(feature = "loadable_extension")] +pub use loadable_extension::loadable_extension_sqlite3_api; + +#[cfg(all(feature = "loadable_extension", feature = "loadable_extension_embedded"))] +pub use loadable_extension::loadable_extension_embedded_init; -#[cfg(all( - feature = "loadable_extension", - not(feature = "loadable_extension_embedded") -))] -// bindings were built with (non-embedded) loadable_extension: -// we define our own (i.e. not extern) sqlite_api static -// variable and export it publicly so that it is included in -// our FFI (C) interface. -#[no_mangle] -pub static mut sqlite3_api: *mut sqlite3_api_routines = 0 as *mut sqlite3_api_routines; +#[cfg(all(feature = "loadable_extension", not(feature = "loadable_extension_embedded")))] +pub use loadable_extension::loadable_extension_init; #[allow(clippy::all)] mod bindings { diff --git a/libsqlite3-sys/src/loadable_extension.rs b/libsqlite3-sys/src/loadable_extension.rs new file mode 100644 index 000000000..48ba98174 --- /dev/null +++ b/libsqlite3-sys/src/loadable_extension.rs @@ -0,0 +1,160 @@ +use crate::sqlite3_api_routines; +use std::sync::Once; + +#[cfg(feature = "loadable_extension_embedded")] +// bindings were built with loadable_extension_embedded: +// define sqlite3_api as an extern since this code will be embedded +// within a loadable extension that defines and exports this itself. +// +// this extern static is immutable so it MUST be set by the embedding +// extension before any of the rust code executes. +extern "C" { + pub static sqlite3_api: *const sqlite3_api_routines; +} + +#[cfg(not(feature = "loadable_extension_embedded"))] +// bindings were built with (non-embedded) loadable_extension: +// we define our own (i.e. not extern) sqlite_api static +// variable and export it publicly so that it is included in +// our FFI (C) interface, in case we are the host to any +// embedded extensions. +// +// This is public only so that it is exported in our library +// for use by any extensions that we embed. +// +// It should not be accessed by any rust code. +#[no_mangle] +pub static mut sqlite3_api: *mut sqlite3_api_routines = std::ptr::null_mut(); + +// Sqlite3ApiRoutines wraps access to the sqlite3_api_routines provided +// to the loadable extension. +struct Sqlite3ApiRoutines { + p_api: *mut sqlite3_api_routines, +} + +impl Sqlite3ApiRoutines { + const UNINIT: Self = Sqlite3ApiRoutines { + p_api: std::ptr::null_mut(), + }; + + #[inline] + fn get(&self) -> *const sqlite3_api_routines { + self.get_mut() as *const sqlite3_api_routines + } + + #[inline] + fn get_mut(&self) -> *mut sqlite3_api_routines { + if self.p_api.is_null() { + panic!("attempted to access Sqlite3ApiRoutines that was not initialized, please ensure you have called loadable_extension_init prior to attempting to use any API functions from a loadable extension"); + } + self.p_api + } +} + +static SQLITE3_API_ONCE: Once = Once::new(); +static mut SQLITE3_API: Sqlite3ApiRoutines = Sqlite3ApiRoutines::UNINIT; + +/// Access the raw pointer to the sqlite3_api_routines after it has been +/// initialized by a call to `loadable_extension_init`.` +/// +/// Will panic if an attempt is made to access it prior to initialization. +/// +/// # Safety +/// +/// This function accesses the mutable static SQLITE3_API which is unsafe, +/// but it is safe provided that SQLITE3_API is only mutated by the +/// `loadable_extension_init` function, which includes a sync::Once guard. +/// +/// A call to this function will panic if it is called prior to the +/// extension being initialized by a call to `loadable_extension_init`. +pub fn loadable_extension_sqlite3_api() -> *const sqlite3_api_routines { + unsafe { + SQLITE3_API.get() + } +} + +#[cfg(not(feature = "loadable_extension_embedded"))] +/// Initialize a (non-embedded) loadable extension +/// +/// This function has essentially the same role as the `SQLITE_EXTENSION_INIT2` +/// macro when building a sqlite loadable extension in C. +/// +/// It is only available when the `loadable_extension` feature is enabled and +/// the `loadable_extension_embedded` feature is not. +/// +/// In general, a sqlite extension that is not embedded should declare a pub +/// extern C function that implements the sqlite extension loading entry point +/// interface (see: https://www.sqlite.org/loadext.html), and that entry point +/// should arrange to call this function before any other rust code is executed. +/// +/// An example minimal sqlite extension entrypoint function might be: +/// ``` +/// #[no_mangle] +/// pub unsafe extern "C" fn sqlite3_extension_init( +/// db: *mut ffi::sqlite3, +/// pz_err_msg: *mut *mut c_char, +/// p_api: *mut ffi::sqlite3_api_routines, +/// ) -> c_int { +/// // SQLITE_EXTENSION_INIT2 equivalent +/// loadable_extension_init(p_api); +/// +/// SQLITE_OK +/// } +/// ``` +/// +/// # Safety +/// +/// The raw pointer passed in to `p_api` must point to a valid `sqlite3_api_routines` +/// struct. +/// +/// The function will panic if a null pointer is provided. +/// +/// This function is thread-safe, but only the first invocation will have any effect. +pub unsafe fn loadable_extension_init(init_p_api: *mut sqlite3_api_routines) { + if init_p_api.is_null() { + panic!("loadable_extension_init was passed a null pointer"); + } + + // protect the setting of SQLITE3_API with a sync::Once so that it is thread-safe. + // only the first invocation will have any effect. + SQLITE3_API_ONCE.call_once(|| { + SQLITE3_API.p_api = init_p_api; + // also set sqlite3_api to the provided value to support hosting of embedded extensions of our own + sqlite3_api = init_p_api; + }); +} + +#[cfg(feature = "loadable_extension_embedded")] +/// Initialize an embedded loadable extension +/// +/// It is only available when the `loadable_extension_embedded` feature is enabled. +/// +/// We rely on the host extension who embeds us (i.e. by linking us in) to +/// implement the sqlite extension entry point itself and set the global symbol +/// `sqlite3_api` to the `sqlite3_api_routines`struct that it was passed from +/// sqlite. With a C extension, that can be done as usual by invoking the +/// `SQLITE_EXTENSION_INIT2` macro from the entry point as recommended in the +/// sqlite loadable extension docs. If the host extension is another rusqlite +/// loadable extension, it will also set the `sqlite3_api` symbol in this case +/// so that extensions that it embeds will have access to the API routines. +/// +/// # Safety +/// +/// The host extension must have already populated `sqlite3_api` to point to +/// a valid `sqlite3_api_routines` struct populated by sqlite and passed to it +/// during its own initialisation. +/// +/// This function will panic if `sqlite3_api` is a null pointer. +/// +/// This function is thread-safe, but only the first invocation will have any effect. +pub unsafe fn loadable_extension_embedded_init() { + if sqlite3_api.is_null() { + panic!("loadable_extension_embedded_init was called with a null `sqlite3_api` - the host extension should have set this (for example by invoking `SQLITE_EXTENSION_INIT2` prior to this function being called)"); + } + + // protect the setting of SQLITE3_API with a sync::Once so that it is thread-safe. + // only the first invocation will have any effect. + SQLITE3_API_ONCE.call_once(|| { + SQLITE3_API.p_api = sqlite3_api as *mut sqlite3_api_routines; + }); +} diff --git a/libsqlite3-sys/upgrade.sh b/libsqlite3-sys/upgrade.sh index ce576e138..a7829b37f 100755 --- a/libsqlite3-sys/upgrade.sh +++ b/libsqlite3-sys/upgrade.sh @@ -37,7 +37,7 @@ function generate_bindgen_binding() { # Regenerate bindgen files generate_bindgen_binding "buildtime_bindgen session" "$SQLITE3_LIB_DIR/bindgen_bundled_version.rs" -generate_bindgen_binding "buildtime_bindgen session loadable_extension" "$SQLITE3_LIB_DIR/bindgen_bundled_version-ext.rs" +generate_bindgen_binding "buildtime_bindgen loadable_extension" "$SQLITE3_LIB_DIR/bindgen_bundled_version-ext.rs" # Sanity checks cd "$SCRIPT_DIR/.." || { echo "fatal error" >&2; exit 1; } From b252f5e88e8452ba567930899d09df0fff5e1910 Mon Sep 17 00:00:00 2001 From: "Joshua C. Randall" Date: Thu, 9 Dec 2021 22:02:24 +0000 Subject: [PATCH 57/61] cargo fmt --- libsqlite3-sys/build.rs | 85 +++++++++++++++++------- libsqlite3-sys/src/lib.rs | 10 ++- libsqlite3-sys/src/loadable_extension.rs | 10 ++- 3 files changed, 73 insertions(+), 32 deletions(-) diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index d07c14a59..a826a3c82 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -680,7 +680,8 @@ mod bindings { // Remove once bindgen can clone: https://github.com/rust-lang/rust-bindgen/issues/2132 #[cfg(feature = "loadable_extension")] { - bindings_with_comments = bindings_with_comments.clang_arg("-DSQLITE_ENABLE_UNLOCK_NOTIFY"); + bindings_with_comments = + bindings_with_comments.clang_arg("-DSQLITE_ENABLE_UNLOCK_NOTIFY"); } } if cfg!(feature = "preupdate_hook") { @@ -688,7 +689,8 @@ mod bindings { // Remove once bindgen can clone: https://github.com/rust-lang/rust-bindgen/issues/2132 #[cfg(feature = "loadable_extension")] { - bindings_with_comments = bindings_with_comments.clang_arg("-DSQLITE_ENABLE_PREUPDATE_HOOK"); + bindings_with_comments = + bindings_with_comments.clang_arg("-DSQLITE_ENABLE_PREUPDATE_HOOK"); } } if cfg!(feature = "session") { @@ -696,7 +698,8 @@ mod bindings { // Remove once bindgen can clone: https://github.com/rust-lang/rust-bindgen/issues/2132 #[cfg(feature = "loadable_extension")] { - bindings_with_comments = bindings_with_comments.clang_arg("-DSQLITE_ENABLE_SESSION"); + bindings_with_comments = + bindings_with_comments.clang_arg("-DSQLITE_ENABLE_SESSION"); } } if win_target() && cfg!(feature = "winsqlite3") { @@ -896,7 +899,8 @@ mod bindings { .unwrap_or_else(|_| panic!("could not run bindgen on header {}", header)) .write(Box::new(&mut output_with_comments)) .expect("could not write output of bindgen with comments"); - let output_with_comments_string = String::from_utf8(output_with_comments).expect("bindgen output with comments was not UTF-8?!"); + let output_with_comments_string = String::from_utf8(output_with_comments) + .expect("bindgen output with comments was not UTF-8?!"); // Get the list of API functions supported by sqlite3_api_routines, // and add wrappers for each of the API functions to dispatch the API @@ -938,7 +942,8 @@ use crate::loadable_extension_sqlite3_api; // compile a regex to match sqlite3 version strings that annotate // fields in the sqlite3_api_routines struct as comments in // the sqlite3ext.h sqlite header file - let version_re = regex::Regex::new(r"[^0-9](?P3[.][0-9]+[.][0-9]+)[^0-9]").expect("failed to compile regex"); + let version_re = regex::Regex::new(r"[^0-9](?P3[.][0-9]+[.][0-9]+)[^0-9]") + .expect("failed to compile regex"); // prior to any version comments, we don't enable any version checks // the earliest version mentioned is 3.3.13, and it appears from the @@ -967,18 +972,31 @@ use crate::loadable_extension_sqlite3_api; for t in attr.tokens.clone().into_iter() { if let proc_macro2::TokenTree::Literal(l) = t { let literal_comments = l.to_string(); - if let Some(captures) = version_re.captures(&literal_comments) { - if let Some(sqlite3_version_match) = captures.name("version") { - let sqlite3_version = sqlite3_version_match.as_str().to_string(); + if let Some(captures) = + version_re.captures(&literal_comments) + { + if let Some(sqlite3_version_match) = + captures.name("version") + { + let sqlite3_version = + sqlite3_version_match.as_str().to_string(); match require_sqlite3_version { None => { - require_sqlite3_version = Some(sqlite3_version); + require_sqlite3_version = + Some(sqlite3_version); } Some(require_sqlite3_version_str) => { - if version_compare::compare_to(&sqlite3_version, &require_sqlite3_version_str, version_compare::Cmp::Lt).expect("failed to compare version strings") { + if version_compare::compare_to( + &sqlite3_version, + &require_sqlite3_version_str, + version_compare::Cmp::Lt, + ) + .expect("failed to compare version strings") + { panic!("Unexpectedly found sqlite3 version requirement in sqlite3ext.h that is lower than the version required for the previous field in sqlite3_api_routines (found '{}' after '{}')", &sqlite3_version, &require_sqlite3_version_str); } else { - require_sqlite3_version = Some(sqlite3_version); + require_sqlite3_version = + Some(sqlite3_version); } } } @@ -1007,14 +1025,20 @@ use crate::loadable_extension_sqlite3_api; } // generate wrapper function and push it to output string - let require_sqlite3_version_with_overrides = if &api_fn_name == "sqlite3_overload_function" { - // override the version requirement for sqlite3_overload_function since it is commented - // with `Added ???` in sqlite3ext.h` - Some("3.3.13") - } else { - require_sqlite3_version.as_deref() - }; - let wrapper = generate_wrapper(ident, field_type, &api_fn_name, require_sqlite3_version_with_overrides); + let require_sqlite3_version_with_overrides = + if &api_fn_name == "sqlite3_overload_function" { + // override the version requirement for sqlite3_overload_function since it is commented + // with `Added ???` in sqlite3ext.h` + Some("3.3.13") + } else { + require_sqlite3_version.as_deref() + }; + let wrapper = generate_wrapper( + ident, + field_type, + &api_fn_name, + require_sqlite3_version_with_overrides, + ); output_string.push_str(&wrapper); } @@ -1260,27 +1284,40 @@ use crate::loadable_extension_sqlite3_api; // For more information, refer to sqlite docs: https://sqlite.org/c3ref/c_source_id.html let api_version_check_tokens = match require_sqlite3_version { Some(version) => { - let require_sqlite3_version = version_compare::Version::from(version).expect("failed to parse required sqlite3 version as Version"); + let require_sqlite3_version = version_compare::Version::from(version) + .expect("failed to parse required sqlite3 version as Version"); let require_sqlite3_version_parts = require_sqlite3_version.parts(); if require_sqlite3_version_parts.len() != 3 { - panic!("sqlite3 version '{}' does not have exactly three parts", version); + panic!( + "sqlite3 version '{}' does not have exactly three parts", + version + ); } let major = match require_sqlite3_version_parts[0] { version_compare::Part::Number(major) => major, _ => { - panic!("non-numeric major part found in sqlite3 version requirement '{}'", require_sqlite3_version_parts[0]); + panic!( + "non-numeric major part found in sqlite3 version requirement '{}'", + require_sqlite3_version_parts[0] + ); } }; let minor = match require_sqlite3_version_parts[1] { version_compare::Part::Number(minor) => minor, _ => { - panic!("non-numeric minor part found in sqlite3 version requirement '{}'", require_sqlite3_version_parts[1]); + panic!( + "non-numeric minor part found in sqlite3 version requirement '{}'", + require_sqlite3_version_parts[1] + ); } }; let patch = match require_sqlite3_version_parts[2] { version_compare::Part::Number(patch) => patch, _ => { - panic!("non-numeric patch part found in sqlite3 version requirement '{}'", require_sqlite3_version_parts[2]); + panic!( + "non-numeric patch part found in sqlite3 version requirement '{}'", + require_sqlite3_version_parts[2] + ); } }; let require_sqlite3_version_number = 1_000_000 * major + 1_000 * minor + patch; diff --git a/libsqlite3-sys/src/lib.rs b/libsqlite3-sys/src/lib.rs index 1ce3238e8..7c2360b80 100644 --- a/libsqlite3-sys/src/lib.rs +++ b/libsqlite3-sys/src/lib.rs @@ -62,10 +62,16 @@ mod loadable_extension; #[cfg(feature = "loadable_extension")] pub use loadable_extension::loadable_extension_sqlite3_api; -#[cfg(all(feature = "loadable_extension", feature = "loadable_extension_embedded"))] +#[cfg(all( + feature = "loadable_extension", + feature = "loadable_extension_embedded" +))] pub use loadable_extension::loadable_extension_embedded_init; -#[cfg(all(feature = "loadable_extension", not(feature = "loadable_extension_embedded")))] +#[cfg(all( + feature = "loadable_extension", + not(feature = "loadable_extension_embedded") +))] pub use loadable_extension::loadable_extension_init; #[allow(clippy::all)] diff --git a/libsqlite3-sys/src/loadable_extension.rs b/libsqlite3-sys/src/loadable_extension.rs index 48ba98174..51c376d4c 100644 --- a/libsqlite3-sys/src/loadable_extension.rs +++ b/libsqlite3-sys/src/loadable_extension.rs @@ -39,15 +39,15 @@ impl Sqlite3ApiRoutines { #[inline] fn get(&self) -> *const sqlite3_api_routines { - self.get_mut() as *const sqlite3_api_routines + self.get_mut() as *const sqlite3_api_routines } #[inline] - fn get_mut(&self) -> *mut sqlite3_api_routines { + fn get_mut(&self) -> *mut sqlite3_api_routines { if self.p_api.is_null() { panic!("attempted to access Sqlite3ApiRoutines that was not initialized, please ensure you have called loadable_extension_init prior to attempting to use any API functions from a loadable extension"); } - self.p_api + self.p_api } } @@ -68,9 +68,7 @@ static mut SQLITE3_API: Sqlite3ApiRoutines = Sqlite3ApiRoutines::UNINIT; /// A call to this function will panic if it is called prior to the /// extension being initialized by a call to `loadable_extension_init`. pub fn loadable_extension_sqlite3_api() -> *const sqlite3_api_routines { - unsafe { - SQLITE3_API.get() - } + unsafe { SQLITE3_API.get() } } #[cfg(not(feature = "loadable_extension_embedded"))] From 55c0c3cfcc350a06b69256c4b2ca41d30a03824f Mon Sep 17 00:00:00 2001 From: "Joshua C. Randall" Date: Thu, 9 Dec 2021 22:06:42 +0000 Subject: [PATCH 58/61] add safety docs to unsafe functions in example-extension and example-embedded-extension --- example-embedded-extension/src/lib.rs | 5 +++++ example-extension/src/lib.rs | 7 +++++++ 2 files changed, 12 insertions(+) diff --git a/example-embedded-extension/src/lib.rs b/example-embedded-extension/src/lib.rs index f0da152b9..aceac63bd 100644 --- a/example-embedded-extension/src/lib.rs +++ b/example-embedded-extension/src/lib.rs @@ -28,6 +28,11 @@ use rusqlite::{to_sqlite_error, Connection, Result}; /// /// It does *not* have to return sqlite status codes (such as SQLITE_OK), we /// just do that here to keep the C extension simple. +/// +/// # Safety +/// +/// The C host extension must pass a pointer to a valid `sqlite3` struct in +/// `db`` and either null or a pointer to a char* in `pz_err_msg`. #[no_mangle] pub unsafe extern "C" fn example_embedded_extension_init( db: *mut ffi::sqlite3, diff --git a/example-extension/src/lib.rs b/example-extension/src/lib.rs index 3f375de6a..2f1b30d3f 100644 --- a/example-extension/src/lib.rs +++ b/example-extension/src/lib.rs @@ -15,6 +15,13 @@ use rusqlite::{to_sqlite_error, Connection, Result}; #[allow(clippy::not_unsafe_ptr_arg_deref)] #[no_mangle] +/// Extension entry point, called by sqlite when this extension is loaded +/// +/// # Safety +/// +/// Sqlite must pass a pointer to a valid `sqlite3` struct in `db``, a pointer to a +/// valid `sqlite3_api_routines` in `p_api`, and either null or a pointer to a char* +/// in `pz_err_msg`. pub unsafe extern "C" fn sqlite3_extension_init( db: *mut ffi::sqlite3, pz_err_msg: *mut *mut c_char, From 069fc87fa12d5ddd220d1550618f0767ec403b39 Mon Sep 17 00:00:00 2001 From: "Joshua C. Randall" Date: Thu, 9 Dec 2021 22:12:05 +0000 Subject: [PATCH 59/61] cargo fmt --- libsqlite3-sys/build.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index a826a3c82..5043c0ccc 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -666,7 +666,7 @@ mod bindings { .header(header.clone()) .parse_callbacks(Box::new(SqliteTypeChooser)) .rustfmt_bindings(true); - + if cfg!(any(feature = "sqlcipher", feature = "bundled-sqlcipher")) { bindings = bindings.clang_arg("-DSQLITE_HAS_CODEC"); // Remove once bindgen can clone: https://github.com/rust-lang/rust-bindgen/issues/2132 From b4ae3e0abaf96ddd792837c53d970d91c123c4cc Mon Sep 17 00:00:00 2001 From: "Joshua C. Randall" Date: Fri, 10 Dec 2021 17:03:23 +0000 Subject: [PATCH 60/61] fix doctests in src/loadable_extension.rs --- libsqlite3-sys/src/loadable_extension.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/libsqlite3-sys/src/loadable_extension.rs b/libsqlite3-sys/src/loadable_extension.rs index 51c376d4c..1cb65bfdb 100644 --- a/libsqlite3-sys/src/loadable_extension.rs +++ b/libsqlite3-sys/src/loadable_extension.rs @@ -89,14 +89,14 @@ pub fn loadable_extension_sqlite3_api() -> *const sqlite3_api_routines { /// ``` /// #[no_mangle] /// pub unsafe extern "C" fn sqlite3_extension_init( -/// db: *mut ffi::sqlite3, -/// pz_err_msg: *mut *mut c_char, -/// p_api: *mut ffi::sqlite3_api_routines, -/// ) -> c_int { +/// db: *mut libsqlite3_sys::sqlite3, +/// pz_err_msg: *mut *mut std::os::raw::c_char, +/// p_api: *mut libsqlite3_sys::sqlite3_api_routines, +/// ) -> std::os::raw::c_int { /// // SQLITE_EXTENSION_INIT2 equivalent -/// loadable_extension_init(p_api); +/// libsqlite3_sys::loadable_extension_init(p_api); /// -/// SQLITE_OK +/// libsqlite3_sys::SQLITE_OK /// } /// ``` /// From 3819e07a55d39430685fed97bbf716335403b835 Mon Sep 17 00:00:00 2001 From: "Joshua C. Randall" Date: Fri, 10 Dec 2021 17:07:49 +0000 Subject: [PATCH 61/61] access sqlite3_api_routines fields in generated wrapper functions using addr_of! and read to avoid undefined behaviour when runtime sqlite3_api_routines is shorter than expected at compile time --- libsqlite3-sys/build.rs | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/libsqlite3-sys/build.rs b/libsqlite3-sys/build.rs index 5043c0ccc..f5760394e 100644 --- a/libsqlite3-sys/build.rs +++ b/libsqlite3-sys/build.rs @@ -1336,9 +1336,10 @@ use crate::loadable_extension_sqlite3_api; pub unsafe fn #api_fn_ident(#api_fn_inputs) #api_fn_output { let p_api = loadable_extension_sqlite3_api(); #api_version_check_tokens - ((*p_api).#field_ident - .expect(stringify!("sqlite3_api contains null pointer for ", #field_name, " function")))( - #(#api_fn_input_idents),* + let api_routine_raw_ptr = core::ptr::addr_of!((*p_api).#field_ident); + (api_routine_raw_ptr.read() + .expect(stringify!("sqlite3_api contains null pointer for ", #field_name, " function")))( + #(#api_fn_input_idents),* ) } };